Available toolchain options (by toolchain)

(see also eb --avail-toolchain-opts <tcname> )

ClangGCC - CrayCCE - CrayGNU - CrayIntel - CrayPGI - FCC - Fujitsu - GCC - GCCcore - GNU - NVHPC - PGI - cgmpich - cgmpolf - cgmvapich2 - cgmvolf - cgompi - cgoolf - ffmpi - foss - fosscuda - gcccuda - gfbf - gimkl - gimpi - gimpic - giolf - giolfc - gmacml - gmkl - gmklc - gmpich2 - gmpich - gmpit - gmpolf - gmvapich2 - gmvolf - goalf - gobff - goblf - gofbf - golf - golfc - gomkl - gomklc - gompi - gompic - goolf - goolfc - gpsmpi - gpsolf - gqacml - gsmpi - gsolf - iccifort - iccifortcuda - ictce - iibff - iimkl - iimklc - iimpi - iimpic - iiqmpi - impich - impmkl - intel-compilers - intel-para - intel - intelcuda - iomkl - iomklc - iompi - iompic - ipsmpi - iqacml - ismkl - nvofbf - nvompi - nvompic - nvpsmpi - nvpsmpic - pmkl - pomkl - pompi - system - xlcxlf - xlmpich2 - xlmpich - xlmvapich2 - xlompi

Available options for ClangGCC toolchain

option description default
32bit Compile 32bit target False
basic-block-vectorize Basic block vectorization False
cciscxx Use CC as CXX False
cstd Specify C standard None
debug Enable debug False
defaultopt Default compiler optimizations False
defaultprec Default precision False
extra_cflags Specify extra CFLAGS options. None
extra_cxxflags Specify extra CXXFLAGS options. None
extra_f90flags Specify extra F90FLAGS options. None
extra_fcflags Specify extra FCFLAGS options. None
extra_fflags Specify extra FFLAGS options. None
i8 Integers are 8 byte integers False
ieee Adhere to IEEE-754 rules False
loop-vectorize Loop vectorization False
loose Loose precision False
lowopt Low compiler optimizations False
noopt Disable compiler optimizations False
openmp Enable OpenMP False
opt High compiler optimizations False
optarch Enable architecture optimizations True
packed-linker-options Pack the linker options as comma separated list False
pic Use PIC False
precise High precision False
r8 Real is 8 byte real False
rpath Use RPATH wrappers when –rpath is enabled in EasyBuild configuration True
shared Build shared library False
static Build static library False
strict Strict (highest) precision False
unroll Unroll loops False
vectorize Enable compiler auto-vectorization, default except for noopt and lowopt None
verbose Verbose output False
veryloose Very loose precision False

Available options for CrayCCE toolchain

option description default
32bit Compile 32bit target False
cciscxx Use CC as CXX False
cstd Specify C standard None
debug Enable debug False
defaultopt Default compiler optimizations False
defaultprec Default precision False
dynamic Generate dynamically linked executable True
extra_cflags Specify extra CFLAGS options. None
extra_cxxflags Specify extra CXXFLAGS options. None
extra_f90flags Specify extra F90FLAGS options. None
extra_fcflags Specify extra FCFLAGS options. None
extra_fflags Specify extra FFLAGS options. None
i8 Integers are 8 byte integers False
ieee Adhere to IEEE-754 rules False
loose Loose precision False
lowopt Low compiler optimizations False
mpich-mt Directs the driver to link in an alternate version of the Cray-MPICH library which provides fine-grained multi-threading support to applications that perform MPI operations within threaded regions. False
noopt Disable compiler optimizations False
openmp Enable OpenMP False
opt High compiler optimizations False
optarch Enable architecture optimizations False
packed-linker-options Pack the linker options as comma separated list False
pic Use PIC False
precise High precision False
r8 Real is 8 byte real False
rpath Use RPATH wrappers when –rpath is enabled in EasyBuild configuration True
shared Build shared library False
static Build static library False
strict Strict (highest) precision False
unroll Unroll loops False
usempi Use MPI compiler as default compiler False
vectorize Enable compiler auto-vectorization, default except for noopt and lowopt None
verbose Verbose output True
veryloose Very loose precision False

Available options for CrayGNU toolchain

option description default
32bit Compile 32bit target False
cciscxx Use CC as CXX False
cstd Specify C standard None
debug Enable debug False
defaultopt Default compiler optimizations False
defaultprec Default precision False
dynamic Generate dynamically linked executable True
extra_cflags Specify extra CFLAGS options. None
extra_cxxflags Specify extra CXXFLAGS options. None
extra_f90flags Specify extra F90FLAGS options. None
extra_fcflags Specify extra FCFLAGS options. None
extra_fflags Specify extra FFLAGS options. None
i8 Integers are 8 byte integers False
ieee Adhere to IEEE-754 rules False
loose Loose precision False
lowopt Low compiler optimizations False
mpich-mt Directs the driver to link in an alternate version of the Cray-MPICH library which provides fine-grained multi-threading support to applications that perform MPI operations within threaded regions. False
noopt Disable compiler optimizations False
openmp Enable OpenMP False
opt High compiler optimizations False
optarch Enable architecture optimizations False
packed-linker-options Pack the linker options as comma separated list False
pic Use PIC False
precise High precision False
r8 Real is 8 byte real False
rpath Use RPATH wrappers when –rpath is enabled in EasyBuild configuration True
shared Build shared library False
static Build static library False
strict Strict (highest) precision False
unroll Unroll loops False
usempi Use MPI compiler as default compiler False
vectorize Enable compiler auto-vectorization, default except for noopt and lowopt None
verbose Verbose output True
veryloose Very loose precision False

Available options for CrayIntel toolchain

option description default
32bit Compile 32bit target False
cciscxx Use CC as CXX False
cstd Specify C standard None
debug Enable debug False
defaultopt Default compiler optimizations False
defaultprec Default precision False
dynamic Generate dynamically linked executable True
extra_cflags Specify extra CFLAGS options. None
extra_cxxflags Specify extra CXXFLAGS options. None
extra_f90flags Specify extra F90FLAGS options. None
extra_fcflags Specify extra FCFLAGS options. None
extra_fflags Specify extra FFLAGS options. None
i8 Integers are 8 byte integers False
ieee Adhere to IEEE-754 rules False
loose Loose precision False
lowopt Low compiler optimizations False
mpich-mt Directs the driver to link in an alternate version of the Cray-MPICH library which provides fine-grained multi-threading support to applications that perform MPI operations within threaded regions. False
noopt Disable compiler optimizations False
openmp Enable OpenMP False
opt High compiler optimizations False
optarch Enable architecture optimizations False
packed-linker-options Pack the linker options as comma separated list False
pic Use PIC False
precise High precision False
r8 Real is 8 byte real False
rpath Use RPATH wrappers when –rpath is enabled in EasyBuild configuration True
shared Build shared library False
static Build static library False
strict Strict (highest) precision False
unroll Unroll loops False
usempi Use MPI compiler as default compiler False
vectorize Enable compiler auto-vectorization, default except for noopt and lowopt None
verbose Verbose output True
veryloose Very loose precision False

Available options for CrayPGI toolchain

option description default
32bit Compile 32bit target False
cciscxx Use CC as CXX False
cstd Specify C standard None
debug Enable debug False
defaultopt Default compiler optimizations False
defaultprec Default precision False
dynamic Generate dynamically linked executable True
extra_cflags Specify extra CFLAGS options. None
extra_cxxflags Specify extra CXXFLAGS options. None
extra_f90flags Specify extra F90FLAGS options. None
extra_fcflags Specify extra FCFLAGS options. None
extra_fflags Specify extra FFLAGS options. None
i8 Integers are 8 byte integers False
ieee Adhere to IEEE-754 rules False
loose Loose precision False
lowopt Low compiler optimizations False
mpich-mt Directs the driver to link in an alternate version of the Cray-MPICH library which provides fine-grained multi-threading support to applications that perform MPI operations within threaded regions. False
noopt Disable compiler optimizations False
openmp Enable OpenMP False
opt High compiler optimizations False
optarch Enable architecture optimizations False
packed-linker-options Pack the linker options as comma separated list False
pic Use PIC False
precise High precision False
r8 Real is 8 byte real False
rpath Use RPATH wrappers when –rpath is enabled in EasyBuild configuration True
shared Build shared library False
static Build static library False
strict Strict (highest) precision False
unroll Unroll loops False
usempi Use MPI compiler as default compiler False
vectorize Enable compiler auto-vectorization, default except for noopt and lowopt None
verbose Verbose output True
veryloose Very loose precision False

Available options for FCC toolchain

option description default
32bit Compile 32bit target False
cciscxx Use CC as CXX False
cstd Specify C standard None
debug Enable debug False
defaultopt Default compiler optimizations False
defaultprec Default precision False
extra_cflags Specify extra CFLAGS options. None
extra_cxxflags Specify extra CXXFLAGS options. None
extra_f90flags Specify extra F90FLAGS options. None
extra_fcflags Specify extra FCFLAGS options. None
extra_fflags Specify extra FFLAGS options. None
i8 Integers are 8 byte integers False
ieee Adhere to IEEE-754 rules False
loose Loose precision False
lowopt Low compiler optimizations False
noopt Disable compiler optimizations False
openmp Enable OpenMP False
opt High compiler optimizations False
optarch Enable architecture optimizations True
packed-linker-options Pack the linker options as comma separated list False
pic Use PIC False
precise High precision False
r8 Real is 8 byte real False
rpath Use RPATH wrappers when –rpath is enabled in EasyBuild configuration True
shared Build shared library False
static Build static library False
strict Strict (highest) precision False
unroll Unroll loops False
vectorize Enable compiler auto-vectorization, default except for noopt and lowopt None
verbose Verbose output False
veryloose Very loose precision False

Available options for Fujitsu toolchain

option description default
32bit Compile 32bit target False
cciscxx Use CC as CXX False
cstd Specify C standard None
debug Enable debug False
defaultopt Default compiler optimizations False
defaultprec Default precision False
extra_cflags Specify extra CFLAGS options. None
extra_cxxflags Specify extra CXXFLAGS options. None
extra_f90flags Specify extra F90FLAGS options. None
extra_fcflags Specify extra FCFLAGS options. None
extra_fflags Specify extra FFLAGS options. None
i8 Integers are 8 byte integers False
ieee Adhere to IEEE-754 rules False
loose Loose precision False
lowopt Low compiler optimizations False
noopt Disable compiler optimizations False
openmp Enable OpenMP False
opt High compiler optimizations False
optarch Enable architecture optimizations True
packed-linker-options Pack the linker options as comma separated list False
pic Use PIC False
precise High precision False
r8 Real is 8 byte real False
rpath Use RPATH wrappers when –rpath is enabled in EasyBuild configuration True
shared Build shared library False
static Build static library False
strict Strict (highest) precision False
unroll Unroll loops False
usempi Use MPI compiler as default compiler False
vectorize Enable compiler auto-vectorization, default except for noopt and lowopt None
verbose Verbose output False
veryloose Very loose precision False

Available options for GCC toolchain

option description default
32bit Compile 32bit target False
cciscxx Use CC as CXX False
cstd Specify C standard None
debug Enable debug False
defaultopt Default compiler optimizations False
defaultprec Default precision False
extra_cflags Specify extra CFLAGS options. None
extra_cxxflags Specify extra CXXFLAGS options. None
extra_f90flags Specify extra F90FLAGS options. None
extra_fcflags Specify extra FCFLAGS options. None
extra_fflags Specify extra FFLAGS options. None
f2c Generate code compatible with f2c and f77 False
i8 Integers are 8 byte integers False
ieee Adhere to IEEE-754 rules False
loop Automatic loop parallellisation False
loose Loose precision False
lowopt Low compiler optimizations False
lto Enable Link Time Optimization False
noopt Disable compiler optimizations False
openmp Enable OpenMP False
opt High compiler optimizations False
optarch Enable architecture optimizations True
packed-linker-options Pack the linker options as comma separated list False
pic Use PIC False
precise High precision False
r8 Real is 8 byte real False
rpath Use RPATH wrappers when –rpath is enabled in EasyBuild configuration True
shared Build shared library False
static Build static library False
strict Strict (highest) precision False
unroll Unroll loops False
vectorize Enable compiler auto-vectorization, default except for noopt and lowopt None
verbose Verbose output False
veryloose Very loose precision False

Available options for GCCcore toolchain

option description default
32bit Compile 32bit target False
cciscxx Use CC as CXX False
cstd Specify C standard None
debug Enable debug False
defaultopt Default compiler optimizations False
defaultprec Default precision False
extra_cflags Specify extra CFLAGS options. None
extra_cxxflags Specify extra CXXFLAGS options. None
extra_f90flags Specify extra F90FLAGS options. None
extra_fcflags Specify extra FCFLAGS options. None
extra_fflags Specify extra FFLAGS options. None
f2c Generate code compatible with f2c and f77 False
i8 Integers are 8 byte integers False
ieee Adhere to IEEE-754 rules False
loop Automatic loop parallellisation False
loose Loose precision False
lowopt Low compiler optimizations False
lto Enable Link Time Optimization False
noopt Disable compiler optimizations False
openmp Enable OpenMP False
opt High compiler optimizations False
optarch Enable architecture optimizations True
packed-linker-options Pack the linker options as comma separated list False
pic Use PIC False
precise High precision False
r8 Real is 8 byte real False
rpath Use RPATH wrappers when –rpath is enabled in EasyBuild configuration True
shared Build shared library False
static Build static library False
strict Strict (highest) precision False
unroll Unroll loops False
vectorize Enable compiler auto-vectorization, default except for noopt and lowopt None
verbose Verbose output False
veryloose Very loose precision False

Available options for GNU toolchain

option description default
32bit Compile 32bit target False
cciscxx Use CC as CXX False
cstd Specify C standard None
debug Enable debug False
defaultopt Default compiler optimizations False
defaultprec Default precision False
extra_cflags Specify extra CFLAGS options. None
extra_cxxflags Specify extra CXXFLAGS options. None
extra_f90flags Specify extra F90FLAGS options. None
extra_fcflags Specify extra FCFLAGS options. None
extra_fflags Specify extra FFLAGS options. None
f2c Generate code compatible with f2c and f77 False
i8 Integers are 8 byte integers False
ieee Adhere to IEEE-754 rules False
loop Automatic loop parallellisation False
loose Loose precision False
lowopt Low compiler optimizations False
lto Enable Link Time Optimization False
noopt Disable compiler optimizations False
openmp Enable OpenMP False
opt High compiler optimizations False
optarch Enable architecture optimizations True
packed-linker-options Pack the linker options as comma separated list False
pic Use PIC False
precise High precision False
r8 Real is 8 byte real False
rpath Use RPATH wrappers when –rpath is enabled in EasyBuild configuration True
shared Build shared library False
static Build static library False
strict Strict (highest) precision False
unroll Unroll loops False
vectorize Enable compiler auto-vectorization, default except for noopt and lowopt None
verbose Verbose output False
veryloose Very loose precision False

Available options for NVHPC toolchain

option description default
32bit Compile 32bit target False
cciscxx Use CC as CXX False
cstd Specify C standard None
debug Enable debug False
defaultopt Default compiler optimizations False
defaultprec Default precision False
extra_cflags Specify extra CFLAGS options. None
extra_cxxflags Specify extra CXXFLAGS options. None
extra_f90flags Specify extra F90FLAGS options. None
extra_fcflags Specify extra FCFLAGS options. None
extra_fflags Specify extra FFLAGS options. None
i8 Integers are 8 byte integers False
ieee Adhere to IEEE-754 rules False
loose Loose precision False
lowopt Low compiler optimizations False
noopt Disable compiler optimizations False
openmp Enable OpenMP False
opt High compiler optimizations False
optarch Enable architecture optimizations True
packed-linker-options Pack the linker options as comma separated list False
pic Use PIC False
precise High precision False
r8 Real is 8 byte real False
rpath Use RPATH wrappers when –rpath is enabled in EasyBuild configuration True
shared Build shared library False
static Build static library False
strict Strict (highest) precision False
unroll Unroll loops False
vectorize Enable compiler auto-vectorization, default except for noopt and lowopt None
verbose Verbose output False
veryloose Very loose precision False

Available options for PGI toolchain

option description default
32bit Compile 32bit target False
cciscxx Use CC as CXX False
cstd Specify C standard None
debug Enable debug False
defaultopt Default compiler optimizations False
defaultprec Default precision False
extra_cflags Specify extra CFLAGS options. None
extra_cxxflags Specify extra CXXFLAGS options. None
extra_f90flags Specify extra F90FLAGS options. None
extra_fcflags Specify extra FCFLAGS options. None
extra_fflags Specify extra FFLAGS options. None
i8 Integers are 8 byte integers False
ieee Adhere to IEEE-754 rules False
loose Loose precision False
lowopt Low compiler optimizations False
noopt Disable compiler optimizations False
openmp Enable OpenMP False
opt High compiler optimizations False
optarch Enable architecture optimizations True
packed-linker-options Pack the linker options as comma separated list False
pic Use PIC False
precise High precision False
r8 Real is 8 byte real False
rpath Use RPATH wrappers when –rpath is enabled in EasyBuild configuration True
shared Build shared library False
static Build static library False
strict Strict (highest) precision False
unroll Unroll loops False
vectorize Enable compiler auto-vectorization, default except for noopt and lowopt None
verbose Verbose output False
veryloose Very loose precision False

Available options for cgmpich toolchain

option description default
32bit Compile 32bit target False
basic-block-vectorize Basic block vectorization False
cciscxx Use CC as CXX False
cstd Specify C standard None
debug Enable debug False
defaultopt Default compiler optimizations False
defaultprec Default precision False
extra_cflags Specify extra CFLAGS options. None
extra_cxxflags Specify extra CXXFLAGS options. None
extra_f90flags Specify extra F90FLAGS options. None
extra_fcflags Specify extra FCFLAGS options. None
extra_fflags Specify extra FFLAGS options. None
i8 Integers are 8 byte integers False
ieee Adhere to IEEE-754 rules False
loop-vectorize Loop vectorization False
loose Loose precision False
lowopt Low compiler optimizations False
noopt Disable compiler optimizations False
openmp Enable OpenMP False
opt High compiler optimizations False
optarch Enable architecture optimizations True
packed-linker-options Pack the linker options as comma separated list False
pic Use PIC False
precise High precision False
r8 Real is 8 byte real False
rpath Use RPATH wrappers when –rpath is enabled in EasyBuild configuration True
shared Build shared library False
static Build static library False
strict Strict (highest) precision False
unroll Unroll loops False
usempi Use MPI compiler as default compiler False
vectorize Enable compiler auto-vectorization, default except for noopt and lowopt None
verbose Verbose output False
veryloose Very loose precision False

Available options for cgmpolf toolchain

option description default
32bit Compile 32bit target False
basic-block-vectorize Basic block vectorization False
cciscxx Use CC as CXX False
cstd Specify C standard None
debug Enable debug False
defaultopt Default compiler optimizations False
defaultprec Default precision False
extra_cflags Specify extra CFLAGS options. None
extra_cxxflags Specify extra CXXFLAGS options. None
extra_f90flags Specify extra F90FLAGS options. None
extra_fcflags Specify extra FCFLAGS options. None
extra_fflags Specify extra FFLAGS options. None
i8 Integers are 8 byte integers False
ieee Adhere to IEEE-754 rules False
loop-vectorize Loop vectorization False
loose Loose precision False
lowopt Low compiler optimizations False
noopt Disable compiler optimizations False
openmp Enable OpenMP False
opt High compiler optimizations False
optarch Enable architecture optimizations True
packed-linker-options Pack the linker options as comma separated list False
pic Use PIC False
precise High precision False
r8 Real is 8 byte real False
rpath Use RPATH wrappers when –rpath is enabled in EasyBuild configuration True
shared Build shared library False
static Build static library False
strict Strict (highest) precision False
unroll Unroll loops False
usempi Use MPI compiler as default compiler False
vectorize Enable compiler auto-vectorization, default except for noopt and lowopt None
verbose Verbose output False
veryloose Very loose precision False

Available options for cgmvapich2 toolchain

option description default
32bit Compile 32bit target False
basic-block-vectorize Basic block vectorization False
cciscxx Use CC as CXX False
cstd Specify C standard None
debug Enable debug False
defaultopt Default compiler optimizations False
defaultprec Default precision False
extra_cflags Specify extra CFLAGS options. None
extra_cxxflags Specify extra CXXFLAGS options. None
extra_f90flags Specify extra F90FLAGS options. None
extra_fcflags Specify extra FCFLAGS options. None
extra_fflags Specify extra FFLAGS options. None
i8 Integers are 8 byte integers False
ieee Adhere to IEEE-754 rules False
loop-vectorize Loop vectorization False
loose Loose precision False
lowopt Low compiler optimizations False
noopt Disable compiler optimizations False
openmp Enable OpenMP False
opt High compiler optimizations False
optarch Enable architecture optimizations True
packed-linker-options Pack the linker options as comma separated list False
pic Use PIC False
precise High precision False
r8 Real is 8 byte real False
rpath Use RPATH wrappers when –rpath is enabled in EasyBuild configuration True
shared Build shared library False
static Build static library False
strict Strict (highest) precision False
unroll Unroll loops False
usempi Use MPI compiler as default compiler False
vectorize Enable compiler auto-vectorization, default except for noopt and lowopt None
verbose Verbose output False
veryloose Very loose precision False

Available options for cgmvolf toolchain

option description default
32bit Compile 32bit target False
basic-block-vectorize Basic block vectorization False
cciscxx Use CC as CXX False
cstd Specify C standard None
debug Enable debug False
defaultopt Default compiler optimizations False
defaultprec Default precision False
extra_cflags Specify extra CFLAGS options. None
extra_cxxflags Specify extra CXXFLAGS options. None
extra_f90flags Specify extra F90FLAGS options. None
extra_fcflags Specify extra FCFLAGS options. None
extra_fflags Specify extra FFLAGS options. None
i8 Integers are 8 byte integers False
ieee Adhere to IEEE-754 rules False
loop-vectorize Loop vectorization False
loose Loose precision False
lowopt Low compiler optimizations False
noopt Disable compiler optimizations False
openmp Enable OpenMP False
opt High compiler optimizations False
optarch Enable architecture optimizations True
packed-linker-options Pack the linker options as comma separated list False
pic Use PIC False
precise High precision False
r8 Real is 8 byte real False
rpath Use RPATH wrappers when –rpath is enabled in EasyBuild configuration True
shared Build shared library False
static Build static library False
strict Strict (highest) precision False
unroll Unroll loops False
usempi Use MPI compiler as default compiler False
vectorize Enable compiler auto-vectorization, default except for noopt and lowopt None
verbose Verbose output False
veryloose Very loose precision False

Available options for cgompi toolchain

option description default
32bit Compile 32bit target False
basic-block-vectorize Basic block vectorization False
cciscxx Use CC as CXX False
cstd Specify C standard None
debug Enable debug False
defaultopt Default compiler optimizations False
defaultprec Default precision False
extra_cflags Specify extra CFLAGS options. None
extra_cxxflags Specify extra CXXFLAGS options. None
extra_f90flags Specify extra F90FLAGS options. None
extra_fcflags Specify extra FCFLAGS options. None
extra_fflags Specify extra FFLAGS options. None
i8 Integers are 8 byte integers False
ieee Adhere to IEEE-754 rules False
loop-vectorize Loop vectorization False
loose Loose precision False
lowopt Low compiler optimizations False
noopt Disable compiler optimizations False
openmp Enable OpenMP False
opt High compiler optimizations False
optarch Enable architecture optimizations True
packed-linker-options Pack the linker options as comma separated list False
pic Use PIC False
precise High precision False
r8 Real is 8 byte real False
rpath Use RPATH wrappers when –rpath is enabled in EasyBuild configuration True
shared Build shared library False
static Build static library False
strict Strict (highest) precision False
unroll Unroll loops False
usempi Use MPI compiler as default compiler False
vectorize Enable compiler auto-vectorization, default except for noopt and lowopt None
verbose Verbose output False
veryloose Very loose precision False

Available options for cgoolf toolchain

option description default
32bit Compile 32bit target False
basic-block-vectorize Basic block vectorization False
cciscxx Use CC as CXX False
cstd Specify C standard None
debug Enable debug False
defaultopt Default compiler optimizations False
defaultprec Default precision False
extra_cflags Specify extra CFLAGS options. None
extra_cxxflags Specify extra CXXFLAGS options. None
extra_f90flags Specify extra F90FLAGS options. None
extra_fcflags Specify extra FCFLAGS options. None
extra_fflags Specify extra FFLAGS options. None
i8 Integers are 8 byte integers False
ieee Adhere to IEEE-754 rules False
loop-vectorize Loop vectorization False
loose Loose precision False
lowopt Low compiler optimizations False
noopt Disable compiler optimizations False
openmp Enable OpenMP False
opt High compiler optimizations False
optarch Enable architecture optimizations True
packed-linker-options Pack the linker options as comma separated list False
pic Use PIC False
precise High precision False
r8 Real is 8 byte real False
rpath Use RPATH wrappers when –rpath is enabled in EasyBuild configuration True
shared Build shared library False
static Build static library False
strict Strict (highest) precision False
unroll Unroll loops False
usempi Use MPI compiler as default compiler False
vectorize Enable compiler auto-vectorization, default except for noopt and lowopt None
verbose Verbose output False
veryloose Very loose precision False

Available options for ffmpi toolchain

option description default
32bit Compile 32bit target False
cciscxx Use CC as CXX False
cstd Specify C standard None
debug Enable debug False
defaultopt Default compiler optimizations False
defaultprec Default precision False
extra_cflags Specify extra CFLAGS options. None
extra_cxxflags Specify extra CXXFLAGS options. None
extra_f90flags Specify extra F90FLAGS options. None
extra_fcflags Specify extra FCFLAGS options. None
extra_fflags Specify extra FFLAGS options. None
i8 Integers are 8 byte integers False
ieee Adhere to IEEE-754 rules False
loose Loose precision False
lowopt Low compiler optimizations False
noopt Disable compiler optimizations False
openmp Enable OpenMP False
opt High compiler optimizations False
optarch Enable architecture optimizations True
packed-linker-options Pack the linker options as comma separated list False
pic Use PIC False
precise High precision False
r8 Real is 8 byte real False
rpath Use RPATH wrappers when –rpath is enabled in EasyBuild configuration True
shared Build shared library False
static Build static library False
strict Strict (highest) precision False
unroll Unroll loops False
usempi Use MPI compiler as default compiler False
vectorize Enable compiler auto-vectorization, default except for noopt and lowopt None
verbose Verbose output False
veryloose Very loose precision False

Available options for foss toolchain

option description default
32bit Compile 32bit target False
cciscxx Use CC as CXX False
cstd Specify C standard None
debug Enable debug False
defaultopt Default compiler optimizations False
defaultprec Default precision False
extra_cflags Specify extra CFLAGS options. None
extra_cxxflags Specify extra CXXFLAGS options. None
extra_f90flags Specify extra F90FLAGS options. None
extra_fcflags Specify extra FCFLAGS options. None
extra_fflags Specify extra FFLAGS options. None
f2c Generate code compatible with f2c and f77 False
i8 Integers are 8 byte integers False
ieee Adhere to IEEE-754 rules False
loop Automatic loop parallellisation False
loose Loose precision False
lowopt Low compiler optimizations False
lto Enable Link Time Optimization False
noopt Disable compiler optimizations False
openmp Enable OpenMP False
opt High compiler optimizations False
optarch Enable architecture optimizations True
packed-linker-options Pack the linker options as comma separated list False
pic Use PIC False
precise High precision False
r8 Real is 8 byte real False
rpath Use RPATH wrappers when –rpath is enabled in EasyBuild configuration True
shared Build shared library False
static Build static library False
strict Strict (highest) precision False
unroll Unroll loops False
usempi Use MPI compiler as default compiler False
vectorize Enable compiler auto-vectorization, default except for noopt and lowopt None
verbose Verbose output False
veryloose Very loose precision False

Available options for fosscuda toolchain

option description default
32bit Compile 32bit target False
cciscxx Use CC as CXX False
cstd Specify C standard None
debug Enable debug False
defaultopt Default compiler optimizations False
defaultprec Default precision False
extra_cflags Specify extra CFLAGS options. None
extra_cxxflags Specify extra CXXFLAGS options. None
extra_f90flags Specify extra F90FLAGS options. None
extra_fcflags Specify extra FCFLAGS options. None
extra_fflags Specify extra FFLAGS options. None
f2c Generate code compatible with f2c and f77 False
i8 Integers are 8 byte integers False
ieee Adhere to IEEE-754 rules False
loop Automatic loop parallellisation False
loose Loose precision False
lowopt Low compiler optimizations False
lto Enable Link Time Optimization False
noopt Disable compiler optimizations False
openmp Enable OpenMP False
opt High compiler optimizations False
optarch Enable architecture optimizations True
packed-linker-options Pack the linker options as comma separated list False
pic Use PIC False
precise High precision False
r8 Real is 8 byte real False
rpath Use RPATH wrappers when –rpath is enabled in EasyBuild configuration True
shared Build shared library False
static Build static library False
strict Strict (highest) precision False
unroll Unroll loops False
usempi Use MPI compiler as default compiler False
vectorize Enable compiler auto-vectorization, default except for noopt and lowopt None
verbose Verbose output False
veryloose Very loose precision False

Available options for gcccuda toolchain

option description default
32bit Compile 32bit target False
cciscxx Use CC as CXX False
cstd Specify C standard None
debug Enable debug False
defaultopt Default compiler optimizations False
defaultprec Default precision False
extra_cflags Specify extra CFLAGS options. None
extra_cxxflags Specify extra CXXFLAGS options. None
extra_f90flags Specify extra F90FLAGS options. None
extra_fcflags Specify extra FCFLAGS options. None
extra_fflags Specify extra FFLAGS options. None
f2c Generate code compatible with f2c and f77 False
i8 Integers are 8 byte integers False
ieee Adhere to IEEE-754 rules False
loop Automatic loop parallellisation False
loose Loose precision False
lowopt Low compiler optimizations False
lto Enable Link Time Optimization False
noopt Disable compiler optimizations False
openmp Enable OpenMP False
opt High compiler optimizations False
optarch Enable architecture optimizations True
packed-linker-options Pack the linker options as comma separated list False
pic Use PIC False
precise High precision False
r8 Real is 8 byte real False
rpath Use RPATH wrappers when –rpath is enabled in EasyBuild configuration True
shared Build shared library False
static Build static library False
strict Strict (highest) precision False
unroll Unroll loops False
vectorize Enable compiler auto-vectorization, default except for noopt and lowopt None
verbose Verbose output False
veryloose Very loose precision False

Available options for gfbf toolchain

option description default
32bit Compile 32bit target False
cciscxx Use CC as CXX False
cstd Specify C standard None
debug Enable debug False
defaultopt Default compiler optimizations False
defaultprec Default precision False
extra_cflags Specify extra CFLAGS options. None
extra_cxxflags Specify extra CXXFLAGS options. None
extra_f90flags Specify extra F90FLAGS options. None
extra_fcflags Specify extra FCFLAGS options. None
extra_fflags Specify extra FFLAGS options. None
f2c Generate code compatible with f2c and f77 False
i8 Integers are 8 byte integers False
ieee Adhere to IEEE-754 rules False
loop Automatic loop parallellisation False
loose Loose precision False
lowopt Low compiler optimizations False
lto Enable Link Time Optimization False
noopt Disable compiler optimizations False
openmp Enable OpenMP False
opt High compiler optimizations False
optarch Enable architecture optimizations True
packed-linker-options Pack the linker options as comma separated list False
pic Use PIC False
precise High precision False
r8 Real is 8 byte real False
rpath Use RPATH wrappers when –rpath is enabled in EasyBuild configuration True
shared Build shared library False
static Build static library False
strict Strict (highest) precision False
unroll Unroll loops False
vectorize Enable compiler auto-vectorization, default except for noopt and lowopt None
verbose Verbose output False
veryloose Very loose precision False

Available options for gimkl toolchain

option description default
32bit Compile 32bit target False
cciscxx Use CC as CXX False
cstd Specify C standard None
debug Enable debug False
defaultopt Default compiler optimizations False
defaultprec Default precision False
extra_cflags Specify extra CFLAGS options. None
extra_cxxflags Specify extra CXXFLAGS options. None
extra_f90flags Specify extra F90FLAGS options. None
extra_fcflags Specify extra FCFLAGS options. None
extra_fflags Specify extra FFLAGS options. None
f2c Generate code compatible with f2c and f77 False
i8 Integers are 8 byte integers False
ieee Adhere to IEEE-754 rules False
loop Automatic loop parallellisation False
loose Loose precision False
lowopt Low compiler optimizations False
lto Enable Link Time Optimization False
noopt Disable compiler optimizations False
openmp Enable OpenMP False
opt High compiler optimizations False
optarch Enable architecture optimizations True
packed-linker-options Pack the linker options as comma separated list False
pic Use PIC False
precise High precision False
r8 Real is 8 byte real False
rpath Use RPATH wrappers when –rpath is enabled in EasyBuild configuration True
shared Build shared library False
static Build static library False
strict Strict (highest) precision False
unroll Unroll loops False
usempi Use MPI compiler as default compiler False
vectorize Enable compiler auto-vectorization, default except for noopt and lowopt None
verbose Verbose output False
veryloose Very loose precision False

Available options for gimpi toolchain

option description default
32bit Compile 32bit target False
cciscxx Use CC as CXX False
cstd Specify C standard None
debug Enable debug False
defaultopt Default compiler optimizations False
defaultprec Default precision False
extra_cflags Specify extra CFLAGS options. None
extra_cxxflags Specify extra CXXFLAGS options. None
extra_f90flags Specify extra F90FLAGS options. None
extra_fcflags Specify extra FCFLAGS options. None
extra_fflags Specify extra FFLAGS options. None
f2c Generate code compatible with f2c and f77 False
i8 Integers are 8 byte integers False
ieee Adhere to IEEE-754 rules False
loop Automatic loop parallellisation False
loose Loose precision False
lowopt Low compiler optimizations False
lto Enable Link Time Optimization False
noopt Disable compiler optimizations False
openmp Enable OpenMP False
opt High compiler optimizations False
optarch Enable architecture optimizations True
packed-linker-options Pack the linker options as comma separated list False
pic Use PIC False
precise High precision False
r8 Real is 8 byte real False
rpath Use RPATH wrappers when –rpath is enabled in EasyBuild configuration True
shared Build shared library False
static Build static library False
strict Strict (highest) precision False
unroll Unroll loops False
usempi Use MPI compiler as default compiler False
vectorize Enable compiler auto-vectorization, default except for noopt and lowopt None
verbose Verbose output False
veryloose Very loose precision False

Available options for gimpic toolchain

option description default
32bit Compile 32bit target False
cciscxx Use CC as CXX False
cstd Specify C standard None
debug Enable debug False
defaultopt Default compiler optimizations False
defaultprec Default precision False
extra_cflags Specify extra CFLAGS options. None
extra_cxxflags Specify extra CXXFLAGS options. None
extra_f90flags Specify extra F90FLAGS options. None
extra_fcflags Specify extra FCFLAGS options. None
extra_fflags Specify extra FFLAGS options. None
f2c Generate code compatible with f2c and f77 False
i8 Integers are 8 byte integers False
ieee Adhere to IEEE-754 rules False
loop Automatic loop parallellisation False
loose Loose precision False
lowopt Low compiler optimizations False
lto Enable Link Time Optimization False
noopt Disable compiler optimizations False
openmp Enable OpenMP False
opt High compiler optimizations False
optarch Enable architecture optimizations True
packed-linker-options Pack the linker options as comma separated list False
pic Use PIC False
precise High precision False
r8 Real is 8 byte real False
rpath Use RPATH wrappers when –rpath is enabled in EasyBuild configuration True
shared Build shared library False
static Build static library False
strict Strict (highest) precision False
unroll Unroll loops False
usempi Use MPI compiler as default compiler False
vectorize Enable compiler auto-vectorization, default except for noopt and lowopt None
verbose Verbose output False
veryloose Very loose precision False

Available options for giolf toolchain

option description default
32bit Compile 32bit target False
cciscxx Use CC as CXX False
cstd Specify C standard None
debug Enable debug False
defaultopt Default compiler optimizations False
defaultprec Default precision False
extra_cflags Specify extra CFLAGS options. None
extra_cxxflags Specify extra CXXFLAGS options. None
extra_f90flags Specify extra F90FLAGS options. None
extra_fcflags Specify extra FCFLAGS options. None
extra_fflags Specify extra FFLAGS options. None
f2c Generate code compatible with f2c and f77 False
i8 Integers are 8 byte integers False
ieee Adhere to IEEE-754 rules False
loop Automatic loop parallellisation False
loose Loose precision False
lowopt Low compiler optimizations False
lto Enable Link Time Optimization False
noopt Disable compiler optimizations False
openmp Enable OpenMP False
opt High compiler optimizations False
optarch Enable architecture optimizations True
packed-linker-options Pack the linker options as comma separated list False
pic Use PIC False
precise High precision False
r8 Real is 8 byte real False
rpath Use RPATH wrappers when –rpath is enabled in EasyBuild configuration True
shared Build shared library False
static Build static library False
strict Strict (highest) precision False
unroll Unroll loops False
usempi Use MPI compiler as default compiler False
vectorize Enable compiler auto-vectorization, default except for noopt and lowopt None
verbose Verbose output False
veryloose Very loose precision False

Available options for giolfc toolchain

option description default
32bit Compile 32bit target False
cciscxx Use CC as CXX False
cstd Specify C standard None
debug Enable debug False
defaultopt Default compiler optimizations False
defaultprec Default precision False
extra_cflags Specify extra CFLAGS options. None
extra_cxxflags Specify extra CXXFLAGS options. None
extra_f90flags Specify extra F90FLAGS options. None
extra_fcflags Specify extra FCFLAGS options. None
extra_fflags Specify extra FFLAGS options. None
f2c Generate code compatible with f2c and f77 False
i8 Integers are 8 byte integers False
ieee Adhere to IEEE-754 rules False
loop Automatic loop parallellisation False
loose Loose precision False
lowopt Low compiler optimizations False
lto Enable Link Time Optimization False
noopt Disable compiler optimizations False
openmp Enable OpenMP False
opt High compiler optimizations False
optarch Enable architecture optimizations True
packed-linker-options Pack the linker options as comma separated list False
pic Use PIC False
precise High precision False
r8 Real is 8 byte real False
rpath Use RPATH wrappers when –rpath is enabled in EasyBuild configuration True
shared Build shared library False
static Build static library False
strict Strict (highest) precision False
unroll Unroll loops False
usempi Use MPI compiler as default compiler False
vectorize Enable compiler auto-vectorization, default except for noopt and lowopt None
verbose Verbose output False
veryloose Very loose precision False

Available options for gmacml toolchain

option description default
32bit Compile 32bit target False
cciscxx Use CC as CXX False
cstd Specify C standard None
debug Enable debug False
defaultopt Default compiler optimizations False
defaultprec Default precision False
extra_cflags Specify extra CFLAGS options. None
extra_cxxflags Specify extra CXXFLAGS options. None
extra_f90flags Specify extra F90FLAGS options. None
extra_fcflags Specify extra FCFLAGS options. None
extra_fflags Specify extra FFLAGS options. None
f2c Generate code compatible with f2c and f77 False
i8 Integers are 8 byte integers False
ieee Adhere to IEEE-754 rules False
loop Automatic loop parallellisation False
loose Loose precision False
lowopt Low compiler optimizations False
lto Enable Link Time Optimization False
noopt Disable compiler optimizations False
openmp Enable OpenMP False
opt High compiler optimizations False
optarch Enable architecture optimizations True
packed-linker-options Pack the linker options as comma separated list False
pic Use PIC False
precise High precision False
r8 Real is 8 byte real False
rpath Use RPATH wrappers when –rpath is enabled in EasyBuild configuration True
shared Build shared library False
static Build static library False
strict Strict (highest) precision False
unroll Unroll loops False
usempi Use MPI compiler as default compiler False
vectorize Enable compiler auto-vectorization, default except for noopt and lowopt None
verbose Verbose output False
veryloose Very loose precision False

Available options for gmkl toolchain

option description default
32bit Compile 32bit target False
cciscxx Use CC as CXX False
cstd Specify C standard None
debug Enable debug False
defaultopt Default compiler optimizations False
defaultprec Default precision False
extra_cflags Specify extra CFLAGS options. None
extra_cxxflags Specify extra CXXFLAGS options. None
extra_f90flags Specify extra F90FLAGS options. None
extra_fcflags Specify extra FCFLAGS options. None
extra_fflags Specify extra FFLAGS options. None
f2c Generate code compatible with f2c and f77 False
i8 Integers are 8 byte integers False
ieee Adhere to IEEE-754 rules False
loop Automatic loop parallellisation False
loose Loose precision False
lowopt Low compiler optimizations False
lto Enable Link Time Optimization False
noopt Disable compiler optimizations False
openmp Enable OpenMP False
opt High compiler optimizations False
optarch Enable architecture optimizations True
packed-linker-options Pack the linker options as comma separated list False
pic Use PIC False
precise High precision False
r8 Real is 8 byte real False
rpath Use RPATH wrappers when –rpath is enabled in EasyBuild configuration True
shared Build shared library False
static Build static library False
strict Strict (highest) precision False
unroll Unroll loops False
vectorize Enable compiler auto-vectorization, default except for noopt and lowopt None
verbose Verbose output False
veryloose Very loose precision False

Available options for gmklc toolchain

option description default
32bit Compile 32bit target False
cciscxx Use CC as CXX False
cstd Specify C standard None
debug Enable debug False
defaultopt Default compiler optimizations False
defaultprec Default precision False
extra_cflags Specify extra CFLAGS options. None
extra_cxxflags Specify extra CXXFLAGS options. None
extra_f90flags Specify extra F90FLAGS options. None
extra_fcflags Specify extra FCFLAGS options. None
extra_fflags Specify extra FFLAGS options. None
f2c Generate code compatible with f2c and f77 False
i8 Integers are 8 byte integers False
ieee Adhere to IEEE-754 rules False
loop Automatic loop parallellisation False
loose Loose precision False
lowopt Low compiler optimizations False
lto Enable Link Time Optimization False
noopt Disable compiler optimizations False
openmp Enable OpenMP False
opt High compiler optimizations False
optarch Enable architecture optimizations True
packed-linker-options Pack the linker options as comma separated list False
pic Use PIC False
precise High precision False
r8 Real is 8 byte real False
rpath Use RPATH wrappers when –rpath is enabled in EasyBuild configuration True
shared Build shared library False
static Build static library False
strict Strict (highest) precision False
unroll Unroll loops False
vectorize Enable compiler auto-vectorization, default except for noopt and lowopt None
verbose Verbose output False
veryloose Very loose precision False

Available options for gmpich2 toolchain

option description default
32bit Compile 32bit target False
cciscxx Use CC as CXX False
cstd Specify C standard None
debug Enable debug False
defaultopt Default compiler optimizations False
defaultprec Default precision False
extra_cflags Specify extra CFLAGS options. None
extra_cxxflags Specify extra CXXFLAGS options. None
extra_f90flags Specify extra F90FLAGS options. None
extra_fcflags Specify extra FCFLAGS options. None
extra_fflags Specify extra FFLAGS options. None
f2c Generate code compatible with f2c and f77 False
i8 Integers are 8 byte integers False
ieee Adhere to IEEE-754 rules False
loop Automatic loop parallellisation False
loose Loose precision False
lowopt Low compiler optimizations False
lto Enable Link Time Optimization False
noopt Disable compiler optimizations False
openmp Enable OpenMP False
opt High compiler optimizations False
optarch Enable architecture optimizations True
packed-linker-options Pack the linker options as comma separated list False
pic Use PIC False
precise High precision False
r8 Real is 8 byte real False
rpath Use RPATH wrappers when –rpath is enabled in EasyBuild configuration True
shared Build shared library False
static Build static library False
strict Strict (highest) precision False
unroll Unroll loops False
usempi Use MPI compiler as default compiler False
vectorize Enable compiler auto-vectorization, default except for noopt and lowopt None
verbose Verbose output False
veryloose Very loose precision False

Available options for gmpich toolchain

option description default
32bit Compile 32bit target False
cciscxx Use CC as CXX False
cstd Specify C standard None
debug Enable debug False
defaultopt Default compiler optimizations False
defaultprec Default precision False
extra_cflags Specify extra CFLAGS options. None
extra_cxxflags Specify extra CXXFLAGS options. None
extra_f90flags Specify extra F90FLAGS options. None
extra_fcflags Specify extra FCFLAGS options. None
extra_fflags Specify extra FFLAGS options. None
f2c Generate code compatible with f2c and f77 False
i8 Integers are 8 byte integers False
ieee Adhere to IEEE-754 rules False
loop Automatic loop parallellisation False
loose Loose precision False
lowopt Low compiler optimizations False
lto Enable Link Time Optimization False
noopt Disable compiler optimizations False
openmp Enable OpenMP False
opt High compiler optimizations False
optarch Enable architecture optimizations True
packed-linker-options Pack the linker options as comma separated list False
pic Use PIC False
precise High precision False
r8 Real is 8 byte real False
rpath Use RPATH wrappers when –rpath is enabled in EasyBuild configuration True
shared Build shared library False
static Build static library False
strict Strict (highest) precision False
unroll Unroll loops False
usempi Use MPI compiler as default compiler False
vectorize Enable compiler auto-vectorization, default except for noopt and lowopt None
verbose Verbose output False
veryloose Very loose precision False

Available options for gmpit toolchain

option description default
32bit Compile 32bit target False
cciscxx Use CC as CXX False
cstd Specify C standard None
debug Enable debug False
defaultopt Default compiler optimizations False
defaultprec Default precision False
extra_cflags Specify extra CFLAGS options. None
extra_cxxflags Specify extra CXXFLAGS options. None
extra_f90flags Specify extra F90FLAGS options. None
extra_fcflags Specify extra FCFLAGS options. None
extra_fflags Specify extra FFLAGS options. None
f2c Generate code compatible with f2c and f77 False
i8 Integers are 8 byte integers False
ieee Adhere to IEEE-754 rules False
loop Automatic loop parallellisation False
loose Loose precision False
lowopt Low compiler optimizations False
lto Enable Link Time Optimization False
noopt Disable compiler optimizations False
openmp Enable OpenMP False
opt High compiler optimizations False
optarch Enable architecture optimizations True
packed-linker-options Pack the linker options as comma separated list False
pic Use PIC False
precise High precision False
r8 Real is 8 byte real False
rpath Use RPATH wrappers when –rpath is enabled in EasyBuild configuration True
shared Build shared library False
static Build static library False
strict Strict (highest) precision False
unroll Unroll loops False
usempi Use MPI compiler as default compiler False
vectorize Enable compiler auto-vectorization, default except for noopt and lowopt None
verbose Verbose output False
veryloose Very loose precision False

Available options for gmpolf toolchain

option description default
32bit Compile 32bit target False
cciscxx Use CC as CXX False
cstd Specify C standard None
debug Enable debug False
defaultopt Default compiler optimizations False
defaultprec Default precision False
extra_cflags Specify extra CFLAGS options. None
extra_cxxflags Specify extra CXXFLAGS options. None
extra_f90flags Specify extra F90FLAGS options. None
extra_fcflags Specify extra FCFLAGS options. None
extra_fflags Specify extra FFLAGS options. None
f2c Generate code compatible with f2c and f77 False
i8 Integers are 8 byte integers False
ieee Adhere to IEEE-754 rules False
loop Automatic loop parallellisation False
loose Loose precision False
lowopt Low compiler optimizations False
lto Enable Link Time Optimization False
noopt Disable compiler optimizations False
openmp Enable OpenMP False
opt High compiler optimizations False
optarch Enable architecture optimizations True
packed-linker-options Pack the linker options as comma separated list False
pic Use PIC False
precise High precision False
r8 Real is 8 byte real False
rpath Use RPATH wrappers when –rpath is enabled in EasyBuild configuration True
shared Build shared library False
static Build static library False
strict Strict (highest) precision False
unroll Unroll loops False
usempi Use MPI compiler as default compiler False
vectorize Enable compiler auto-vectorization, default except for noopt and lowopt None
verbose Verbose output False
veryloose Very loose precision False

Available options for gmvapich2 toolchain

option description default
32bit Compile 32bit target False
cciscxx Use CC as CXX False
cstd Specify C standard None
debug Enable debug False
defaultopt Default compiler optimizations False
defaultprec Default precision False
extra_cflags Specify extra CFLAGS options. None
extra_cxxflags Specify extra CXXFLAGS options. None
extra_f90flags Specify extra F90FLAGS options. None
extra_fcflags Specify extra FCFLAGS options. None
extra_fflags Specify extra FFLAGS options. None
f2c Generate code compatible with f2c and f77 False
i8 Integers are 8 byte integers False
ieee Adhere to IEEE-754 rules False
loop Automatic loop parallellisation False
loose Loose precision False
lowopt Low compiler optimizations False
lto Enable Link Time Optimization False
noopt Disable compiler optimizations False
openmp Enable OpenMP False
opt High compiler optimizations False
optarch Enable architecture optimizations True
packed-linker-options Pack the linker options as comma separated list False
pic Use PIC False
precise High precision False
r8 Real is 8 byte real False
rpath Use RPATH wrappers when –rpath is enabled in EasyBuild configuration True
shared Build shared library False
static Build static library False
strict Strict (highest) precision False
unroll Unroll loops False
usempi Use MPI compiler as default compiler False
vectorize Enable compiler auto-vectorization, default except for noopt and lowopt None
verbose Verbose output False
veryloose Very loose precision False

Available options for gmvolf toolchain

option description default
32bit Compile 32bit target False
cciscxx Use CC as CXX False
cstd Specify C standard None
debug Enable debug False
defaultopt Default compiler optimizations False
defaultprec Default precision False
extra_cflags Specify extra CFLAGS options. None
extra_cxxflags Specify extra CXXFLAGS options. None
extra_f90flags Specify extra F90FLAGS options. None
extra_fcflags Specify extra FCFLAGS options. None
extra_fflags Specify extra FFLAGS options. None
f2c Generate code compatible with f2c and f77 False
i8 Integers are 8 byte integers False
ieee Adhere to IEEE-754 rules False
loop Automatic loop parallellisation False
loose Loose precision False
lowopt Low compiler optimizations False
lto Enable Link Time Optimization False
noopt Disable compiler optimizations False
openmp Enable OpenMP False
opt High compiler optimizations False
optarch Enable architecture optimizations True
packed-linker-options Pack the linker options as comma separated list False
pic Use PIC False
precise High precision False
r8 Real is 8 byte real False
rpath Use RPATH wrappers when –rpath is enabled in EasyBuild configuration True
shared Build shared library False
static Build static library False
strict Strict (highest) precision False
unroll Unroll loops False
usempi Use MPI compiler as default compiler False
vectorize Enable compiler auto-vectorization, default except for noopt and lowopt None
verbose Verbose output False
veryloose Very loose precision False

Available options for goalf toolchain

option description default
32bit Compile 32bit target False
cciscxx Use CC as CXX False
cstd Specify C standard None
debug Enable debug False
defaultopt Default compiler optimizations False
defaultprec Default precision False
extra_cflags Specify extra CFLAGS options. None
extra_cxxflags Specify extra CXXFLAGS options. None
extra_f90flags Specify extra F90FLAGS options. None
extra_fcflags Specify extra FCFLAGS options. None
extra_fflags Specify extra FFLAGS options. None
f2c Generate code compatible with f2c and f77 False
i8 Integers are 8 byte integers False
ieee Adhere to IEEE-754 rules False
loop Automatic loop parallellisation False
loose Loose precision False
lowopt Low compiler optimizations False
lto Enable Link Time Optimization False
noopt Disable compiler optimizations False
openmp Enable OpenMP False
opt High compiler optimizations False
optarch Enable architecture optimizations True
packed-linker-options Pack the linker options as comma separated list False
pic Use PIC False
precise High precision False
r8 Real is 8 byte real False
rpath Use RPATH wrappers when –rpath is enabled in EasyBuild configuration True
shared Build shared library False
static Build static library False
strict Strict (highest) precision False
unroll Unroll loops False
usempi Use MPI compiler as default compiler False
vectorize Enable compiler auto-vectorization, default except for noopt and lowopt None
verbose Verbose output False
veryloose Very loose precision False

Available options for gobff toolchain

option description default
32bit Compile 32bit target False
cciscxx Use CC as CXX False
cstd Specify C standard None
debug Enable debug False
defaultopt Default compiler optimizations False
defaultprec Default precision False
extra_cflags Specify extra CFLAGS options. None
extra_cxxflags Specify extra CXXFLAGS options. None
extra_f90flags Specify extra F90FLAGS options. None
extra_fcflags Specify extra FCFLAGS options. None
extra_fflags Specify extra FFLAGS options. None
f2c Generate code compatible with f2c and f77 False
i8 Integers are 8 byte integers False
ieee Adhere to IEEE-754 rules False
loop Automatic loop parallellisation False
loose Loose precision False
lowopt Low compiler optimizations False
lto Enable Link Time Optimization False
noopt Disable compiler optimizations False
openmp Enable OpenMP False
opt High compiler optimizations False
optarch Enable architecture optimizations True
packed-linker-options Pack the linker options as comma separated list False
pic Use PIC False
precise High precision False
r8 Real is 8 byte real False
rpath Use RPATH wrappers when –rpath is enabled in EasyBuild configuration True
shared Build shared library False
static Build static library False
strict Strict (highest) precision False
unroll Unroll loops False
usempi Use MPI compiler as default compiler False
vectorize Enable compiler auto-vectorization, default except for noopt and lowopt None
verbose Verbose output False
veryloose Very loose precision False

Available options for goblf toolchain

option description default
32bit Compile 32bit target False
cciscxx Use CC as CXX False
cstd Specify C standard None
debug Enable debug False
defaultopt Default compiler optimizations False
defaultprec Default precision False
extra_cflags Specify extra CFLAGS options. None
extra_cxxflags Specify extra CXXFLAGS options. None
extra_f90flags Specify extra F90FLAGS options. None
extra_fcflags Specify extra FCFLAGS options. None
extra_fflags Specify extra FFLAGS options. None
f2c Generate code compatible with f2c and f77 False
i8 Integers are 8 byte integers False
ieee Adhere to IEEE-754 rules False
loop Automatic loop parallellisation False
loose Loose precision False
lowopt Low compiler optimizations False
lto Enable Link Time Optimization False
noopt Disable compiler optimizations False
openmp Enable OpenMP False
opt High compiler optimizations False
optarch Enable architecture optimizations True
packed-linker-options Pack the linker options as comma separated list False
pic Use PIC False
precise High precision False
r8 Real is 8 byte real False
rpath Use RPATH wrappers when –rpath is enabled in EasyBuild configuration True
shared Build shared library False
static Build static library False
strict Strict (highest) precision False
unroll Unroll loops False
usempi Use MPI compiler as default compiler False
vectorize Enable compiler auto-vectorization, default except for noopt and lowopt None
verbose Verbose output False
veryloose Very loose precision False

Available options for gofbf toolchain

option description default
32bit Compile 32bit target False
cciscxx Use CC as CXX False
cstd Specify C standard None
debug Enable debug False
defaultopt Default compiler optimizations False
defaultprec Default precision False
extra_cflags Specify extra CFLAGS options. None
extra_cxxflags Specify extra CXXFLAGS options. None
extra_f90flags Specify extra F90FLAGS options. None
extra_fcflags Specify extra FCFLAGS options. None
extra_fflags Specify extra FFLAGS options. None
f2c Generate code compatible with f2c and f77 False
i8 Integers are 8 byte integers False
ieee Adhere to IEEE-754 rules False
loop Automatic loop parallellisation False
loose Loose precision False
lowopt Low compiler optimizations False
lto Enable Link Time Optimization False
noopt Disable compiler optimizations False
openmp Enable OpenMP False
opt High compiler optimizations False
optarch Enable architecture optimizations True
packed-linker-options Pack the linker options as comma separated list False
pic Use PIC False
precise High precision False
r8 Real is 8 byte real False
rpath Use RPATH wrappers when –rpath is enabled in EasyBuild configuration True
shared Build shared library False
static Build static library False
strict Strict (highest) precision False
unroll Unroll loops False
usempi Use MPI compiler as default compiler False
vectorize Enable compiler auto-vectorization, default except for noopt and lowopt None
verbose Verbose output False
veryloose Very loose precision False

Available options for golf toolchain

option description default
32bit Compile 32bit target False
cciscxx Use CC as CXX False
cstd Specify C standard None
debug Enable debug False
defaultopt Default compiler optimizations False
defaultprec Default precision False
extra_cflags Specify extra CFLAGS options. None
extra_cxxflags Specify extra CXXFLAGS options. None
extra_f90flags Specify extra F90FLAGS options. None
extra_fcflags Specify extra FCFLAGS options. None
extra_fflags Specify extra FFLAGS options. None
f2c Generate code compatible with f2c and f77 False
i8 Integers are 8 byte integers False
ieee Adhere to IEEE-754 rules False
loop Automatic loop parallellisation False
loose Loose precision False
lowopt Low compiler optimizations False
lto Enable Link Time Optimization False
noopt Disable compiler optimizations False
openmp Enable OpenMP False
opt High compiler optimizations False
optarch Enable architecture optimizations True
packed-linker-options Pack the linker options as comma separated list False
pic Use PIC False
precise High precision False
r8 Real is 8 byte real False
rpath Use RPATH wrappers when –rpath is enabled in EasyBuild configuration True
shared Build shared library False
static Build static library False
strict Strict (highest) precision False
unroll Unroll loops False
vectorize Enable compiler auto-vectorization, default except for noopt and lowopt None
verbose Verbose output False
veryloose Very loose precision False

Available options for golfc toolchain

option description default
32bit Compile 32bit target False
cciscxx Use CC as CXX False
cstd Specify C standard None
debug Enable debug False
defaultopt Default compiler optimizations False
defaultprec Default precision False
extra_cflags Specify extra CFLAGS options. None
extra_cxxflags Specify extra CXXFLAGS options. None
extra_f90flags Specify extra F90FLAGS options. None
extra_fcflags Specify extra FCFLAGS options. None
extra_fflags Specify extra FFLAGS options. None
f2c Generate code compatible with f2c and f77 False
i8 Integers are 8 byte integers False
ieee Adhere to IEEE-754 rules False
loop Automatic loop parallellisation False
loose Loose precision False
lowopt Low compiler optimizations False
lto Enable Link Time Optimization False
noopt Disable compiler optimizations False
openmp Enable OpenMP False
opt High compiler optimizations False
optarch Enable architecture optimizations True
packed-linker-options Pack the linker options as comma separated list False
pic Use PIC False
precise High precision False
r8 Real is 8 byte real False
rpath Use RPATH wrappers when –rpath is enabled in EasyBuild configuration True
shared Build shared library False
static Build static library False
strict Strict (highest) precision False
unroll Unroll loops False
vectorize Enable compiler auto-vectorization, default except for noopt and lowopt None
verbose Verbose output False
veryloose Very loose precision False

Available options for gomkl toolchain

option description default
32bit Compile 32bit target False
cciscxx Use CC as CXX False
cstd Specify C standard None
debug Enable debug False
defaultopt Default compiler optimizations False
defaultprec Default precision False
extra_cflags Specify extra CFLAGS options. None
extra_cxxflags Specify extra CXXFLAGS options. None
extra_f90flags Specify extra F90FLAGS options. None
extra_fcflags Specify extra FCFLAGS options. None
extra_fflags Specify extra FFLAGS options. None
f2c Generate code compatible with f2c and f77 False
i8 Integers are 8 byte integers False
ieee Adhere to IEEE-754 rules False
loop Automatic loop parallellisation False
loose Loose precision False
lowopt Low compiler optimizations False
lto Enable Link Time Optimization False
noopt Disable compiler optimizations False
openmp Enable OpenMP False
opt High compiler optimizations False
optarch Enable architecture optimizations True
packed-linker-options Pack the linker options as comma separated list False
pic Use PIC False
precise High precision False
r8 Real is 8 byte real False
rpath Use RPATH wrappers when –rpath is enabled in EasyBuild configuration True
shared Build shared library False
static Build static library False
strict Strict (highest) precision False
unroll Unroll loops False
usempi Use MPI compiler as default compiler False
vectorize Enable compiler auto-vectorization, default except for noopt and lowopt None
verbose Verbose output False
veryloose Very loose precision False

Available options for gomklc toolchain

option description default
32bit Compile 32bit target False
cciscxx Use CC as CXX False
cstd Specify C standard None
debug Enable debug False
defaultopt Default compiler optimizations False
defaultprec Default precision False
extra_cflags Specify extra CFLAGS options. None
extra_cxxflags Specify extra CXXFLAGS options. None
extra_f90flags Specify extra F90FLAGS options. None
extra_fcflags Specify extra FCFLAGS options. None
extra_fflags Specify extra FFLAGS options. None
f2c Generate code compatible with f2c and f77 False
i8 Integers are 8 byte integers False
ieee Adhere to IEEE-754 rules False
loop Automatic loop parallellisation False
loose Loose precision False
lowopt Low compiler optimizations False
lto Enable Link Time Optimization False
noopt Disable compiler optimizations False
openmp Enable OpenMP False
opt High compiler optimizations False
optarch Enable architecture optimizations True
packed-linker-options Pack the linker options as comma separated list False
pic Use PIC False
precise High precision False
r8 Real is 8 byte real False
rpath Use RPATH wrappers when –rpath is enabled in EasyBuild configuration True
shared Build shared library False
static Build static library False
strict Strict (highest) precision False
unroll Unroll loops False
usempi Use MPI compiler as default compiler False
vectorize Enable compiler auto-vectorization, default except for noopt and lowopt None
verbose Verbose output False
veryloose Very loose precision False

Available options for gompi toolchain

option description default
32bit Compile 32bit target False
cciscxx Use CC as CXX False
cstd Specify C standard None
debug Enable debug False
defaultopt Default compiler optimizations False
defaultprec Default precision False
extra_cflags Specify extra CFLAGS options. None
extra_cxxflags Specify extra CXXFLAGS options. None
extra_f90flags Specify extra F90FLAGS options. None
extra_fcflags Specify extra FCFLAGS options. None
extra_fflags Specify extra FFLAGS options. None
f2c Generate code compatible with f2c and f77 False
i8 Integers are 8 byte integers False
ieee Adhere to IEEE-754 rules False
loop Automatic loop parallellisation False
loose Loose precision False
lowopt Low compiler optimizations False
lto Enable Link Time Optimization False
noopt Disable compiler optimizations False
openmp Enable OpenMP False
opt High compiler optimizations False
optarch Enable architecture optimizations True
packed-linker-options Pack the linker options as comma separated list False
pic Use PIC False
precise High precision False
r8 Real is 8 byte real False
rpath Use RPATH wrappers when –rpath is enabled in EasyBuild configuration True
shared Build shared library False
static Build static library False
strict Strict (highest) precision False
unroll Unroll loops False
usempi Use MPI compiler as default compiler False
vectorize Enable compiler auto-vectorization, default except for noopt and lowopt None
verbose Verbose output False
veryloose Very loose precision False

Available options for gompic toolchain

option description default
32bit Compile 32bit target False
cciscxx Use CC as CXX False
cstd Specify C standard None
debug Enable debug False
defaultopt Default compiler optimizations False
defaultprec Default precision False
extra_cflags Specify extra CFLAGS options. None
extra_cxxflags Specify extra CXXFLAGS options. None
extra_f90flags Specify extra F90FLAGS options. None
extra_fcflags Specify extra FCFLAGS options. None
extra_fflags Specify extra FFLAGS options. None
f2c Generate code compatible with f2c and f77 False
i8 Integers are 8 byte integers False
ieee Adhere to IEEE-754 rules False
loop Automatic loop parallellisation False
loose Loose precision False
lowopt Low compiler optimizations False
lto Enable Link Time Optimization False
noopt Disable compiler optimizations False
openmp Enable OpenMP False
opt High compiler optimizations False
optarch Enable architecture optimizations True
packed-linker-options Pack the linker options as comma separated list False
pic Use PIC False
precise High precision False
r8 Real is 8 byte real False
rpath Use RPATH wrappers when –rpath is enabled in EasyBuild configuration True
shared Build shared library False
static Build static library False
strict Strict (highest) precision False
unroll Unroll loops False
usempi Use MPI compiler as default compiler False
vectorize Enable compiler auto-vectorization, default except for noopt and lowopt None
verbose Verbose output False
veryloose Very loose precision False

Available options for goolf toolchain

option description default
32bit Compile 32bit target False
cciscxx Use CC as CXX False
cstd Specify C standard None
debug Enable debug False
defaultopt Default compiler optimizations False
defaultprec Default precision False
extra_cflags Specify extra CFLAGS options. None
extra_cxxflags Specify extra CXXFLAGS options. None
extra_f90flags Specify extra F90FLAGS options. None
extra_fcflags Specify extra FCFLAGS options. None
extra_fflags Specify extra FFLAGS options. None
f2c Generate code compatible with f2c and f77 False
i8 Integers are 8 byte integers False
ieee Adhere to IEEE-754 rules False
loop Automatic loop parallellisation False
loose Loose precision False
lowopt Low compiler optimizations False
lto Enable Link Time Optimization False
noopt Disable compiler optimizations False
openmp Enable OpenMP False
opt High compiler optimizations False
optarch Enable architecture optimizations True
packed-linker-options Pack the linker options as comma separated list False
pic Use PIC False
precise High precision False
r8 Real is 8 byte real False
rpath Use RPATH wrappers when –rpath is enabled in EasyBuild configuration True
shared Build shared library False
static Build static library False
strict Strict (highest) precision False
unroll Unroll loops False
usempi Use MPI compiler as default compiler False
vectorize Enable compiler auto-vectorization, default except for noopt and lowopt None
verbose Verbose output False
veryloose Very loose precision False

Available options for goolfc toolchain

option description default
32bit Compile 32bit target False
cciscxx Use CC as CXX False
cstd Specify C standard None
debug Enable debug False
defaultopt Default compiler optimizations False
defaultprec Default precision False
extra_cflags Specify extra CFLAGS options. None
extra_cxxflags Specify extra CXXFLAGS options. None
extra_f90flags Specify extra F90FLAGS options. None
extra_fcflags Specify extra FCFLAGS options. None
extra_fflags Specify extra FFLAGS options. None
f2c Generate code compatible with f2c and f77 False
i8 Integers are 8 byte integers False
ieee Adhere to IEEE-754 rules False
loop Automatic loop parallellisation False
loose Loose precision False
lowopt Low compiler optimizations False
lto Enable Link Time Optimization False
noopt Disable compiler optimizations False
openmp Enable OpenMP False
opt High compiler optimizations False
optarch Enable architecture optimizations True
packed-linker-options Pack the linker options as comma separated list False
pic Use PIC False
precise High precision False
r8 Real is 8 byte real False
rpath Use RPATH wrappers when –rpath is enabled in EasyBuild configuration True
shared Build shared library False
static Build static library False
strict Strict (highest) precision False
unroll Unroll loops False
usempi Use MPI compiler as default compiler False
vectorize Enable compiler auto-vectorization, default except for noopt and lowopt None
verbose Verbose output False
veryloose Very loose precision False

Available options for gpsmpi toolchain

option description default
32bit Compile 32bit target False
cciscxx Use CC as CXX False
cstd Specify C standard None
debug Enable debug False
defaultopt Default compiler optimizations False
defaultprec Default precision False
extra_cflags Specify extra CFLAGS options. None
extra_cxxflags Specify extra CXXFLAGS options. None
extra_f90flags Specify extra F90FLAGS options. None
extra_fcflags Specify extra FCFLAGS options. None
extra_fflags Specify extra FFLAGS options. None
f2c Generate code compatible with f2c and f77 False
i8 Integers are 8 byte integers False
ieee Adhere to IEEE-754 rules False
loop Automatic loop parallellisation False
loose Loose precision False
lowopt Low compiler optimizations False
lto Enable Link Time Optimization False
noopt Disable compiler optimizations False
openmp Enable OpenMP False
opt High compiler optimizations False
optarch Enable architecture optimizations True
packed-linker-options Pack the linker options as comma separated list False
pic Use PIC False
precise High precision False
r8 Real is 8 byte real False
rpath Use RPATH wrappers when –rpath is enabled in EasyBuild configuration True
shared Build shared library False
static Build static library False
strict Strict (highest) precision False
unroll Unroll loops False
usempi Use MPI compiler as default compiler False
vectorize Enable compiler auto-vectorization, default except for noopt and lowopt None
verbose Verbose output False
veryloose Very loose precision False

Available options for gpsolf toolchain

option description default
32bit Compile 32bit target False
cciscxx Use CC as CXX False
cstd Specify C standard None
debug Enable debug False
defaultopt Default compiler optimizations False
defaultprec Default precision False
extra_cflags Specify extra CFLAGS options. None
extra_cxxflags Specify extra CXXFLAGS options. None
extra_f90flags Specify extra F90FLAGS options. None
extra_fcflags Specify extra FCFLAGS options. None
extra_fflags Specify extra FFLAGS options. None
f2c Generate code compatible with f2c and f77 False
i8 Integers are 8 byte integers False
ieee Adhere to IEEE-754 rules False
loop Automatic loop parallellisation False
loose Loose precision False
lowopt Low compiler optimizations False
lto Enable Link Time Optimization False
noopt Disable compiler optimizations False
openmp Enable OpenMP False
opt High compiler optimizations False
optarch Enable architecture optimizations True
packed-linker-options Pack the linker options as comma separated list False
pic Use PIC False
precise High precision False
r8 Real is 8 byte real False
rpath Use RPATH wrappers when –rpath is enabled in EasyBuild configuration True
shared Build shared library False
static Build static library False
strict Strict (highest) precision False
unroll Unroll loops False
usempi Use MPI compiler as default compiler False
vectorize Enable compiler auto-vectorization, default except for noopt and lowopt None
verbose Verbose output False
veryloose Very loose precision False

Available options for gqacml toolchain

option description default
32bit Compile 32bit target False
cciscxx Use CC as CXX False
cstd Specify C standard None
debug Enable debug False
defaultopt Default compiler optimizations False
defaultprec Default precision False
extra_cflags Specify extra CFLAGS options. None
extra_cxxflags Specify extra CXXFLAGS options. None
extra_f90flags Specify extra F90FLAGS options. None
extra_fcflags Specify extra FCFLAGS options. None
extra_fflags Specify extra FFLAGS options. None
f2c Generate code compatible with f2c and f77 False
i8 Integers are 8 byte integers False
ieee Adhere to IEEE-754 rules False
loop Automatic loop parallellisation False
loose Loose precision False
lowopt Low compiler optimizations False
lto Enable Link Time Optimization False
noopt Disable compiler optimizations False
openmp Enable OpenMP False
opt High compiler optimizations False
optarch Enable architecture optimizations True
packed-linker-options Pack the linker options as comma separated list False
pic Use PIC False
precise High precision False
r8 Real is 8 byte real False
rpath Use RPATH wrappers when –rpath is enabled in EasyBuild configuration True
shared Build shared library False
static Build static library False
strict Strict (highest) precision False
unroll Unroll loops False
usempi Use MPI compiler as default compiler False
vectorize Enable compiler auto-vectorization, default except for noopt and lowopt None
verbose Verbose output False
veryloose Very loose precision False

Available options for gsmpi toolchain

option description default
32bit Compile 32bit target False
cciscxx Use CC as CXX False
cstd Specify C standard None
debug Enable debug False
defaultopt Default compiler optimizations False
defaultprec Default precision False
extra_cflags Specify extra CFLAGS options. None
extra_cxxflags Specify extra CXXFLAGS options. None
extra_f90flags Specify extra F90FLAGS options. None
extra_fcflags Specify extra FCFLAGS options. None
extra_fflags Specify extra FFLAGS options. None
f2c Generate code compatible with f2c and f77 False
i8 Integers are 8 byte integers False
ieee Adhere to IEEE-754 rules False
loop Automatic loop parallellisation False
loose Loose precision False
lowopt Low compiler optimizations False
lto Enable Link Time Optimization False
noopt Disable compiler optimizations False
openmp Enable OpenMP False
opt High compiler optimizations False
optarch Enable architecture optimizations True
packed-linker-options Pack the linker options as comma separated list False
pic Use PIC False
precise High precision False
r8 Real is 8 byte real False
rpath Use RPATH wrappers when –rpath is enabled in EasyBuild configuration True
shared Build shared library False
static Build static library False
strict Strict (highest) precision False
unroll Unroll loops False
usempi Use MPI compiler as default compiler False
vectorize Enable compiler auto-vectorization, default except for noopt and lowopt None
verbose Verbose output False
veryloose Very loose precision False

Available options for gsolf toolchain

option description default
32bit Compile 32bit target False
cciscxx Use CC as CXX False
cstd Specify C standard None
debug Enable debug False
defaultopt Default compiler optimizations False
defaultprec Default precision False
extra_cflags Specify extra CFLAGS options. None
extra_cxxflags Specify extra CXXFLAGS options. None
extra_f90flags Specify extra F90FLAGS options. None
extra_fcflags Specify extra FCFLAGS options. None
extra_fflags Specify extra FFLAGS options. None
f2c Generate code compatible with f2c and f77 False
i8 Integers are 8 byte integers False
ieee Adhere to IEEE-754 rules False
loop Automatic loop parallellisation False
loose Loose precision False
lowopt Low compiler optimizations False
lto Enable Link Time Optimization False
noopt Disable compiler optimizations False
openmp Enable OpenMP False
opt High compiler optimizations False
optarch Enable architecture optimizations True
packed-linker-options Pack the linker options as comma separated list False
pic Use PIC False
precise High precision False
r8 Real is 8 byte real False
rpath Use RPATH wrappers when –rpath is enabled in EasyBuild configuration True
shared Build shared library False
static Build static library False
strict Strict (highest) precision False
unroll Unroll loops False
usempi Use MPI compiler as default compiler False
vectorize Enable compiler auto-vectorization, default except for noopt and lowopt None
verbose Verbose output False
veryloose Very loose precision False

Available options for iccifort toolchain

option description default
32bit Compile 32bit target False
cciscxx Use CC as CXX False
cstd Specify C standard None
debug Enable debug False
defaultopt Default compiler optimizations False
defaultprec Default precision False
error-unknown-option Error instead of warning for unknown options False
extra_cflags Specify extra CFLAGS options. None
extra_cxxflags Specify extra CXXFLAGS options. None
extra_f90flags Specify extra F90FLAGS options. None
extra_fcflags Specify extra FCFLAGS options. None
extra_fflags Specify extra FFLAGS options. None
i8 Integers are 8 byte integers False
ieee Adhere to IEEE-754 rules False
intel-static Link Intel provided libraries statically False
loose Loose precision False
lowopt Low compiler optimizations False
no-icc Don’t set Intel specific macros False
noopt Disable compiler optimizations False
openmp Enable OpenMP False
opt High compiler optimizations False
optarch Enable architecture optimizations True
packed-linker-options Pack the linker options as comma separated list False
pic Use PIC False
precise High precision False
r8 Real is 8 byte real False
rpath Use RPATH wrappers when –rpath is enabled in EasyBuild configuration True
shared Build shared library False
static Build static library False
strict Strict (highest) precision False
unroll Unroll loops False
vectorize Enable compiler auto-vectorization, default except for noopt and lowopt None
verbose Verbose output False
veryloose Very loose precision False

Available options for iccifortcuda toolchain

option description default
32bit Compile 32bit target False
cciscxx Use CC as CXX False
cstd Specify C standard None
debug Enable debug False
defaultopt Default compiler optimizations False
defaultprec Default precision False
error-unknown-option Error instead of warning for unknown options False
extra_cflags Specify extra CFLAGS options. None
extra_cxxflags Specify extra CXXFLAGS options. None
extra_f90flags Specify extra F90FLAGS options. None
extra_fcflags Specify extra FCFLAGS options. None
extra_fflags Specify extra FFLAGS options. None
i8 Integers are 8 byte integers False
ieee Adhere to IEEE-754 rules False
intel-static Link Intel provided libraries statically False
loose Loose precision False
lowopt Low compiler optimizations False
no-icc Don’t set Intel specific macros False
noopt Disable compiler optimizations False
openmp Enable OpenMP False
opt High compiler optimizations False
optarch Enable architecture optimizations True
packed-linker-options Pack the linker options as comma separated list False
pic Use PIC False
precise High precision False
r8 Real is 8 byte real False
rpath Use RPATH wrappers when –rpath is enabled in EasyBuild configuration True
shared Build shared library False
static Build static library False
strict Strict (highest) precision False
unroll Unroll loops False
vectorize Enable compiler auto-vectorization, default except for noopt and lowopt None
verbose Verbose output False
veryloose Very loose precision False

Available options for ictce toolchain

option description default
32bit Compile 32bit target False
cciscxx Use CC as CXX False
cstd Specify C standard None
debug Enable debug False
defaultopt Default compiler optimizations False
defaultprec Default precision False
error-unknown-option Error instead of warning for unknown options False
extra_cflags Specify extra CFLAGS options. None
extra_cxxflags Specify extra CXXFLAGS options. None
extra_f90flags Specify extra F90FLAGS options. None
extra_fcflags Specify extra FCFLAGS options. None
extra_fflags Specify extra FFLAGS options. None
i8 Integers are 8 byte integers False
ieee Adhere to IEEE-754 rules False
intel-static Link Intel provided libraries statically False
loose Loose precision False
lowopt Low compiler optimizations False
no-icc Don’t set Intel specific macros False
noopt Disable compiler optimizations False
oneapi Use oneAPI compilers icx/icpx/ifx instead of classic compilers None
oneapi_c_cxx Use oneAPI C/C++ compilers icx/icpx instead of classic Intel C/C++ compilers (auto-enabled for Intel compilers version 2022.2.0, or newer) None
oneapi_fortran Use oneAPI Fortran compiler ifx instead of classic Intel Fortran compiler False
openmp Enable OpenMP False
opt High compiler optimizations False
optarch Enable architecture optimizations True
packed-linker-options Pack the linker options as comma separated list False
pic Use PIC False
precise High precision False
r8 Real is 8 byte real False
rpath Use RPATH wrappers when –rpath is enabled in EasyBuild configuration True
shared Build shared library False
static Build static library False
strict Strict (highest) precision False
unroll Unroll loops False
usempi Use MPI compiler as default compiler False
vectorize Enable compiler auto-vectorization, default except for noopt and lowopt None
verbose Verbose output False
veryloose Very loose precision False

Available options for iibff toolchain

option description default
32bit Compile 32bit target False
cciscxx Use CC as CXX False
cstd Specify C standard None
debug Enable debug False
defaultopt Default compiler optimizations False
defaultprec Default precision False
error-unknown-option Error instead of warning for unknown options False
extra_cflags Specify extra CFLAGS options. None
extra_cxxflags Specify extra CXXFLAGS options. None
extra_f90flags Specify extra F90FLAGS options. None
extra_fcflags Specify extra FCFLAGS options. None
extra_fflags Specify extra FFLAGS options. None
i8 Integers are 8 byte integers False
ieee Adhere to IEEE-754 rules False
intel-static Link Intel provided libraries statically False
loose Loose precision False
lowopt Low compiler optimizations False
no-icc Don’t set Intel specific macros False
noopt Disable compiler optimizations False
oneapi Use oneAPI compilers icx/icpx/ifx instead of classic compilers None
oneapi_c_cxx Use oneAPI C/C++ compilers icx/icpx instead of classic Intel C/C++ compilers (auto-enabled for Intel compilers version 2022.2.0, or newer) None
oneapi_fortran Use oneAPI Fortran compiler ifx instead of classic Intel Fortran compiler False
openmp Enable OpenMP False
opt High compiler optimizations False
optarch Enable architecture optimizations True
packed-linker-options Pack the linker options as comma separated list False
pic Use PIC False
precise High precision False
r8 Real is 8 byte real False
rpath Use RPATH wrappers when –rpath is enabled in EasyBuild configuration True
shared Build shared library False
static Build static library False
strict Strict (highest) precision False
unroll Unroll loops False
usempi Use MPI compiler as default compiler False
vectorize Enable compiler auto-vectorization, default except for noopt and lowopt None
verbose Verbose output False
veryloose Very loose precision False

Available options for iimkl toolchain

option description default
32bit Compile 32bit target False
cciscxx Use CC as CXX False
cstd Specify C standard None
debug Enable debug False
defaultopt Default compiler optimizations False
defaultprec Default precision False
error-unknown-option Error instead of warning for unknown options False
extra_cflags Specify extra CFLAGS options. None
extra_cxxflags Specify extra CXXFLAGS options. None
extra_f90flags Specify extra F90FLAGS options. None
extra_fcflags Specify extra FCFLAGS options. None
extra_fflags Specify extra FFLAGS options. None
i8 Integers are 8 byte integers False
ieee Adhere to IEEE-754 rules False
intel-static Link Intel provided libraries statically False
loose Loose precision False
lowopt Low compiler optimizations False
no-icc Don’t set Intel specific macros False
noopt Disable compiler optimizations False
oneapi Use oneAPI compilers icx/icpx/ifx instead of classic compilers None
oneapi_c_cxx Use oneAPI C/C++ compilers icx/icpx instead of classic Intel C/C++ compilers (auto-enabled for Intel compilers version 2022.2.0, or newer) None
oneapi_fortran Use oneAPI Fortran compiler ifx instead of classic Intel Fortran compiler False
openmp Enable OpenMP False
opt High compiler optimizations False
optarch Enable architecture optimizations True
packed-linker-options Pack the linker options as comma separated list False
pic Use PIC False
precise High precision False
r8 Real is 8 byte real False
rpath Use RPATH wrappers when –rpath is enabled in EasyBuild configuration True
shared Build shared library False
static Build static library False
strict Strict (highest) precision False
unroll Unroll loops False
vectorize Enable compiler auto-vectorization, default except for noopt and lowopt None
verbose Verbose output False
veryloose Very loose precision False

Available options for iimklc toolchain

option description default
32bit Compile 32bit target False
cciscxx Use CC as CXX False
cstd Specify C standard None
debug Enable debug False
defaultopt Default compiler optimizations False
defaultprec Default precision False
error-unknown-option Error instead of warning for unknown options False
extra_cflags Specify extra CFLAGS options. None
extra_cxxflags Specify extra CXXFLAGS options. None
extra_f90flags Specify extra F90FLAGS options. None
extra_fcflags Specify extra FCFLAGS options. None
extra_fflags Specify extra FFLAGS options. None
i8 Integers are 8 byte integers False
ieee Adhere to IEEE-754 rules False
intel-static Link Intel provided libraries statically False
loose Loose precision False
lowopt Low compiler optimizations False
no-icc Don’t set Intel specific macros False
noopt Disable compiler optimizations False
oneapi Use oneAPI compilers icx/icpx/ifx instead of classic compilers None
oneapi_c_cxx Use oneAPI C/C++ compilers icx/icpx instead of classic Intel C/C++ compilers (auto-enabled for Intel compilers version 2022.2.0, or newer) None
oneapi_fortran Use oneAPI Fortran compiler ifx instead of classic Intel Fortran compiler False
openmp Enable OpenMP False
opt High compiler optimizations False
optarch Enable architecture optimizations True
packed-linker-options Pack the linker options as comma separated list False
pic Use PIC False
precise High precision False
r8 Real is 8 byte real False
rpath Use RPATH wrappers when –rpath is enabled in EasyBuild configuration True
shared Build shared library False
static Build static library False
strict Strict (highest) precision False
unroll Unroll loops False
vectorize Enable compiler auto-vectorization, default except for noopt and lowopt None
verbose Verbose output False
veryloose Very loose precision False

Available options for iimpi toolchain

option description default
32bit Compile 32bit target False
cciscxx Use CC as CXX False
cstd Specify C standard None
debug Enable debug False
defaultopt Default compiler optimizations False
defaultprec Default precision False
error-unknown-option Error instead of warning for unknown options False
extra_cflags Specify extra CFLAGS options. None
extra_cxxflags Specify extra CXXFLAGS options. None
extra_f90flags Specify extra F90FLAGS options. None
extra_fcflags Specify extra FCFLAGS options. None
extra_fflags Specify extra FFLAGS options. None
i8 Integers are 8 byte integers False
ieee Adhere to IEEE-754 rules False
intel-static Link Intel provided libraries statically False
loose Loose precision False
lowopt Low compiler optimizations False
no-icc Don’t set Intel specific macros False
noopt Disable compiler optimizations False
oneapi Use oneAPI compilers icx/icpx/ifx instead of classic compilers None
oneapi_c_cxx Use oneAPI C/C++ compilers icx/icpx instead of classic Intel C/C++ compilers (auto-enabled for Intel compilers version 2022.2.0, or newer) None
oneapi_fortran Use oneAPI Fortran compiler ifx instead of classic Intel Fortran compiler False
openmp Enable OpenMP False
opt High compiler optimizations False
optarch Enable architecture optimizations True
packed-linker-options Pack the linker options as comma separated list False
pic Use PIC False
precise High precision False
r8 Real is 8 byte real False
rpath Use RPATH wrappers when –rpath is enabled in EasyBuild configuration True
shared Build shared library False
static Build static library False
strict Strict (highest) precision False
unroll Unroll loops False
usempi Use MPI compiler as default compiler False
vectorize Enable compiler auto-vectorization, default except for noopt and lowopt None
verbose Verbose output False
veryloose Very loose precision False

Available options for iimpic toolchain

option description default
32bit Compile 32bit target False
cciscxx Use CC as CXX False
cstd Specify C standard None
debug Enable debug False
defaultopt Default compiler optimizations False
defaultprec Default precision False
error-unknown-option Error instead of warning for unknown options False
extra_cflags Specify extra CFLAGS options. None
extra_cxxflags Specify extra CXXFLAGS options. None
extra_f90flags Specify extra F90FLAGS options. None
extra_fcflags Specify extra FCFLAGS options. None
extra_fflags Specify extra FFLAGS options. None
i8 Integers are 8 byte integers False
ieee Adhere to IEEE-754 rules False
intel-static Link Intel provided libraries statically False
loose Loose precision False
lowopt Low compiler optimizations False
no-icc Don’t set Intel specific macros False
noopt Disable compiler optimizations False
openmp Enable OpenMP False
opt High compiler optimizations False
optarch Enable architecture optimizations True
packed-linker-options Pack the linker options as comma separated list False
pic Use PIC False
precise High precision False
r8 Real is 8 byte real False
rpath Use RPATH wrappers when –rpath is enabled in EasyBuild configuration True
shared Build shared library False
static Build static library False
strict Strict (highest) precision False
unroll Unroll loops False
usempi Use MPI compiler as default compiler False
vectorize Enable compiler auto-vectorization, default except for noopt and lowopt None
verbose Verbose output False
veryloose Very loose precision False

Available options for iiqmpi toolchain

option description default
32bit Compile 32bit target False
cciscxx Use CC as CXX False
cstd Specify C standard None
debug Enable debug False
defaultopt Default compiler optimizations False
defaultprec Default precision False
error-unknown-option Error instead of warning for unknown options False
extra_cflags Specify extra CFLAGS options. None
extra_cxxflags Specify extra CXXFLAGS options. None
extra_f90flags Specify extra F90FLAGS options. None
extra_fcflags Specify extra FCFLAGS options. None
extra_fflags Specify extra FFLAGS options. None
i8 Integers are 8 byte integers False
ieee Adhere to IEEE-754 rules False
intel-static Link Intel provided libraries statically False
loose Loose precision False
lowopt Low compiler optimizations False
no-icc Don’t set Intel specific macros False
noopt Disable compiler optimizations False
openmp Enable OpenMP False
opt High compiler optimizations False
optarch Enable architecture optimizations True
packed-linker-options Pack the linker options as comma separated list False
pic Use PIC False
precise High precision False
r8 Real is 8 byte real False
rpath Use RPATH wrappers when –rpath is enabled in EasyBuild configuration True
shared Build shared library False
static Build static library False
strict Strict (highest) precision False
unroll Unroll loops False
usempi Use MPI compiler as default compiler False
vectorize Enable compiler auto-vectorization, default except for noopt and lowopt None
verbose Verbose output False
veryloose Very loose precision False

Available options for impich toolchain

option description default
32bit Compile 32bit target False
cciscxx Use CC as CXX False
cstd Specify C standard None
debug Enable debug False
defaultopt Default compiler optimizations False
defaultprec Default precision False
error-unknown-option Error instead of warning for unknown options False
extra_cflags Specify extra CFLAGS options. None
extra_cxxflags Specify extra CXXFLAGS options. None
extra_f90flags Specify extra F90FLAGS options. None
extra_fcflags Specify extra FCFLAGS options. None
extra_fflags Specify extra FFLAGS options. None
i8 Integers are 8 byte integers False
ieee Adhere to IEEE-754 rules False
intel-static Link Intel provided libraries statically False
loose Loose precision False
lowopt Low compiler optimizations False
no-icc Don’t set Intel specific macros False
noopt Disable compiler optimizations False
openmp Enable OpenMP False
opt High compiler optimizations False
optarch Enable architecture optimizations True
packed-linker-options Pack the linker options as comma separated list False
pic Use PIC False
precise High precision False
r8 Real is 8 byte real False
rpath Use RPATH wrappers when –rpath is enabled in EasyBuild configuration True
shared Build shared library False
static Build static library False
strict Strict (highest) precision False
unroll Unroll loops False
usempi Use MPI compiler as default compiler False
vectorize Enable compiler auto-vectorization, default except for noopt and lowopt None
verbose Verbose output False
veryloose Very loose precision False

Available options for impmkl toolchain

option description default
32bit Compile 32bit target False
cciscxx Use CC as CXX False
cstd Specify C standard None
debug Enable debug False
defaultopt Default compiler optimizations False
defaultprec Default precision False
error-unknown-option Error instead of warning for unknown options False
extra_cflags Specify extra CFLAGS options. None
extra_cxxflags Specify extra CXXFLAGS options. None
extra_f90flags Specify extra F90FLAGS options. None
extra_fcflags Specify extra FCFLAGS options. None
extra_fflags Specify extra FFLAGS options. None
i8 Integers are 8 byte integers False
ieee Adhere to IEEE-754 rules False
intel-static Link Intel provided libraries statically False
loose Loose precision False
lowopt Low compiler optimizations False
no-icc Don’t set Intel specific macros False
noopt Disable compiler optimizations False
openmp Enable OpenMP False
opt High compiler optimizations False
optarch Enable architecture optimizations True
packed-linker-options Pack the linker options as comma separated list False
pic Use PIC False
precise High precision False
r8 Real is 8 byte real False
rpath Use RPATH wrappers when –rpath is enabled in EasyBuild configuration True
shared Build shared library False
static Build static library False
strict Strict (highest) precision False
unroll Unroll loops False
usempi Use MPI compiler as default compiler False
vectorize Enable compiler auto-vectorization, default except for noopt and lowopt None
verbose Verbose output False
veryloose Very loose precision False

Available options for intel-compilers toolchain

option description default
32bit Compile 32bit target False
cciscxx Use CC as CXX False
cstd Specify C standard None
debug Enable debug False
defaultopt Default compiler optimizations False
defaultprec Default precision False
error-unknown-option Error instead of warning for unknown options False
extra_cflags Specify extra CFLAGS options. None
extra_cxxflags Specify extra CXXFLAGS options. None
extra_f90flags Specify extra F90FLAGS options. None
extra_fcflags Specify extra FCFLAGS options. None
extra_fflags Specify extra FFLAGS options. None
i8 Integers are 8 byte integers False
ieee Adhere to IEEE-754 rules False
intel-static Link Intel provided libraries statically False
loose Loose precision False
lowopt Low compiler optimizations False
no-icc Don’t set Intel specific macros False
noopt Disable compiler optimizations False
oneapi Use oneAPI compilers icx/icpx/ifx instead of classic compilers None
oneapi_c_cxx Use oneAPI C/C++ compilers icx/icpx instead of classic Intel C/C++ compilers (auto-enabled for Intel compilers version 2022.2.0, or newer) None
oneapi_fortran Use oneAPI Fortran compiler ifx instead of classic Intel Fortran compiler False
openmp Enable OpenMP False
opt High compiler optimizations False
optarch Enable architecture optimizations True
packed-linker-options Pack the linker options as comma separated list False
pic Use PIC False
precise High precision False
r8 Real is 8 byte real False
rpath Use RPATH wrappers when –rpath is enabled in EasyBuild configuration True
shared Build shared library False
static Build static library False
strict Strict (highest) precision False
unroll Unroll loops False
vectorize Enable compiler auto-vectorization, default except for noopt and lowopt None
verbose Verbose output False
veryloose Very loose precision False

Available options for intel-para toolchain

option description default
32bit Compile 32bit target False
cciscxx Use CC as CXX False
cstd Specify C standard None
debug Enable debug False
defaultopt Default compiler optimizations False
defaultprec Default precision False
error-unknown-option Error instead of warning for unknown options False
extra_cflags Specify extra CFLAGS options. None
extra_cxxflags Specify extra CXXFLAGS options. None
extra_f90flags Specify extra F90FLAGS options. None
extra_fcflags Specify extra FCFLAGS options. None
extra_fflags Specify extra FFLAGS options. None
i8 Integers are 8 byte integers False
ieee Adhere to IEEE-754 rules False
intel-static Link Intel provided libraries statically False
loose Loose precision False
lowopt Low compiler optimizations False
no-icc Don’t set Intel specific macros False
noopt Disable compiler optimizations False
openmp Enable OpenMP False
opt High compiler optimizations False
optarch Enable architecture optimizations True
packed-linker-options Pack the linker options as comma separated list False
pic Use PIC False
precise High precision False
r8 Real is 8 byte real False
rpath Use RPATH wrappers when –rpath is enabled in EasyBuild configuration True
shared Build shared library False
static Build static library False
strict Strict (highest) precision False
unroll Unroll loops False
usempi Use MPI compiler as default compiler False
vectorize Enable compiler auto-vectorization, default except for noopt and lowopt None
verbose Verbose output False
veryloose Very loose precision False

Available options for intel toolchain

option description default
32bit Compile 32bit target False
cciscxx Use CC as CXX False
cstd Specify C standard None
debug Enable debug False
defaultopt Default compiler optimizations False
defaultprec Default precision False
error-unknown-option Error instead of warning for unknown options False
extra_cflags Specify extra CFLAGS options. None
extra_cxxflags Specify extra CXXFLAGS options. None
extra_f90flags Specify extra F90FLAGS options. None
extra_fcflags Specify extra FCFLAGS options. None
extra_fflags Specify extra FFLAGS options. None
i8 Integers are 8 byte integers False
ieee Adhere to IEEE-754 rules False
intel-static Link Intel provided libraries statically False
loose Loose precision False
lowopt Low compiler optimizations False
no-icc Don’t set Intel specific macros False
noopt Disable compiler optimizations False
oneapi Use oneAPI compilers icx/icpx/ifx instead of classic compilers None
oneapi_c_cxx Use oneAPI C/C++ compilers icx/icpx instead of classic Intel C/C++ compilers (auto-enabled for Intel compilers version 2022.2.0, or newer) None
oneapi_fortran Use oneAPI Fortran compiler ifx instead of classic Intel Fortran compiler False
openmp Enable OpenMP False
opt High compiler optimizations False
optarch Enable architecture optimizations True
packed-linker-options Pack the linker options as comma separated list False
pic Use PIC False
precise High precision False
r8 Real is 8 byte real False
rpath Use RPATH wrappers when –rpath is enabled in EasyBuild configuration True
shared Build shared library False
static Build static library False
strict Strict (highest) precision False
unroll Unroll loops False
usempi Use MPI compiler as default compiler False
vectorize Enable compiler auto-vectorization, default except for noopt and lowopt None
verbose Verbose output False
veryloose Very loose precision False

Available options for intelcuda toolchain

option description default
32bit Compile 32bit target False
cciscxx Use CC as CXX False
cstd Specify C standard None
debug Enable debug False
defaultopt Default compiler optimizations False
defaultprec Default precision False
error-unknown-option Error instead of warning for unknown options False
extra_cflags Specify extra CFLAGS options. None
extra_cxxflags Specify extra CXXFLAGS options. None
extra_f90flags Specify extra F90FLAGS options. None
extra_fcflags Specify extra FCFLAGS options. None
extra_fflags Specify extra FFLAGS options. None
i8 Integers are 8 byte integers False
ieee Adhere to IEEE-754 rules False
intel-static Link Intel provided libraries statically False
loose Loose precision False
lowopt Low compiler optimizations False
no-icc Don’t set Intel specific macros False
noopt Disable compiler optimizations False
openmp Enable OpenMP False
opt High compiler optimizations False
optarch Enable architecture optimizations True
packed-linker-options Pack the linker options as comma separated list False
pic Use PIC False
precise High precision False
r8 Real is 8 byte real False
rpath Use RPATH wrappers when –rpath is enabled in EasyBuild configuration True
shared Build shared library False
static Build static library False
strict Strict (highest) precision False
unroll Unroll loops False
usempi Use MPI compiler as default compiler False
vectorize Enable compiler auto-vectorization, default except for noopt and lowopt None
verbose Verbose output False
veryloose Very loose precision False

Available options for iomkl toolchain

option description default
32bit Compile 32bit target False
cciscxx Use CC as CXX False
cstd Specify C standard None
debug Enable debug False
defaultopt Default compiler optimizations False
defaultprec Default precision False
error-unknown-option Error instead of warning for unknown options False
extra_cflags Specify extra CFLAGS options. None
extra_cxxflags Specify extra CXXFLAGS options. None
extra_f90flags Specify extra F90FLAGS options. None
extra_fcflags Specify extra FCFLAGS options. None
extra_fflags Specify extra FFLAGS options. None
i8 Integers are 8 byte integers False
ieee Adhere to IEEE-754 rules False
intel-static Link Intel provided libraries statically False
loose Loose precision False
lowopt Low compiler optimizations False
no-icc Don’t set Intel specific macros False
noopt Disable compiler optimizations False
oneapi Use oneAPI compilers icx/icpx/ifx instead of classic compilers None
oneapi_c_cxx Use oneAPI C/C++ compilers icx/icpx instead of classic Intel C/C++ compilers (auto-enabled for Intel compilers version 2022.2.0, or newer) None
oneapi_fortran Use oneAPI Fortran compiler ifx instead of classic Intel Fortran compiler False
openmp Enable OpenMP False
opt High compiler optimizations False
optarch Enable architecture optimizations True
packed-linker-options Pack the linker options as comma separated list False
pic Use PIC False
precise High precision False
r8 Real is 8 byte real False
rpath Use RPATH wrappers when –rpath is enabled in EasyBuild configuration True
shared Build shared library False
static Build static library False
strict Strict (highest) precision False
unroll Unroll loops False
usempi Use MPI compiler as default compiler False
vectorize Enable compiler auto-vectorization, default except for noopt and lowopt None
verbose Verbose output False
veryloose Very loose precision False

Available options for iomklc toolchain

option description default
32bit Compile 32bit target False
cciscxx Use CC as CXX False
cstd Specify C standard None
debug Enable debug False
defaultopt Default compiler optimizations False
defaultprec Default precision False
error-unknown-option Error instead of warning for unknown options False
extra_cflags Specify extra CFLAGS options. None
extra_cxxflags Specify extra CXXFLAGS options. None
extra_f90flags Specify extra F90FLAGS options. None
extra_fcflags Specify extra FCFLAGS options. None
extra_fflags Specify extra FFLAGS options. None
i8 Integers are 8 byte integers False
ieee Adhere to IEEE-754 rules False
intel-static Link Intel provided libraries statically False
loose Loose precision False
lowopt Low compiler optimizations False
no-icc Don’t set Intel specific macros False
noopt Disable compiler optimizations False
openmp Enable OpenMP False
opt High compiler optimizations False
optarch Enable architecture optimizations True
packed-linker-options Pack the linker options as comma separated list False
pic Use PIC False
precise High precision False
r8 Real is 8 byte real False
rpath Use RPATH wrappers when –rpath is enabled in EasyBuild configuration True
shared Build shared library False
static Build static library False
strict Strict (highest) precision False
unroll Unroll loops False
usempi Use MPI compiler as default compiler False
vectorize Enable compiler auto-vectorization, default except for noopt and lowopt None
verbose Verbose output False
veryloose Very loose precision False

Available options for iompi toolchain

option description default
32bit Compile 32bit target False
cciscxx Use CC as CXX False
cstd Specify C standard None
debug Enable debug False
defaultopt Default compiler optimizations False
defaultprec Default precision False
error-unknown-option Error instead of warning for unknown options False
extra_cflags Specify extra CFLAGS options. None
extra_cxxflags Specify extra CXXFLAGS options. None
extra_f90flags Specify extra F90FLAGS options. None
extra_fcflags Specify extra FCFLAGS options. None
extra_fflags Specify extra FFLAGS options. None
i8 Integers are 8 byte integers False
ieee Adhere to IEEE-754 rules False
intel-static Link Intel provided libraries statically False
loose Loose precision False
lowopt Low compiler optimizations False
no-icc Don’t set Intel specific macros False
noopt Disable compiler optimizations False
oneapi Use oneAPI compilers icx/icpx/ifx instead of classic compilers None
oneapi_c_cxx Use oneAPI C/C++ compilers icx/icpx instead of classic Intel C/C++ compilers (auto-enabled for Intel compilers version 2022.2.0, or newer) None
oneapi_fortran Use oneAPI Fortran compiler ifx instead of classic Intel Fortran compiler False
openmp Enable OpenMP False
opt High compiler optimizations False
optarch Enable architecture optimizations True
packed-linker-options Pack the linker options as comma separated list False
pic Use PIC False
precise High precision False
r8 Real is 8 byte real False
rpath Use RPATH wrappers when –rpath is enabled in EasyBuild configuration True
shared Build shared library False
static Build static library False
strict Strict (highest) precision False
unroll Unroll loops False
usempi Use MPI compiler as default compiler False
vectorize Enable compiler auto-vectorization, default except for noopt and lowopt None
verbose Verbose output False
veryloose Very loose precision False

Available options for iompic toolchain

option description default
32bit Compile 32bit target False
cciscxx Use CC as CXX False
cstd Specify C standard None
debug Enable debug False
defaultopt Default compiler optimizations False
defaultprec Default precision False
error-unknown-option Error instead of warning for unknown options False
extra_cflags Specify extra CFLAGS options. None
extra_cxxflags Specify extra CXXFLAGS options. None
extra_f90flags Specify extra F90FLAGS options. None
extra_fcflags Specify extra FCFLAGS options. None
extra_fflags Specify extra FFLAGS options. None
i8 Integers are 8 byte integers False
ieee Adhere to IEEE-754 rules False
intel-static Link Intel provided libraries statically False
loose Loose precision False
lowopt Low compiler optimizations False
no-icc Don’t set Intel specific macros False
noopt Disable compiler optimizations False
openmp Enable OpenMP False
opt High compiler optimizations False
optarch Enable architecture optimizations True
packed-linker-options Pack the linker options as comma separated list False
pic Use PIC False
precise High precision False
r8 Real is 8 byte real False
rpath Use RPATH wrappers when –rpath is enabled in EasyBuild configuration True
shared Build shared library False
static Build static library False
strict Strict (highest) precision False
unroll Unroll loops False
usempi Use MPI compiler as default compiler False
vectorize Enable compiler auto-vectorization, default except for noopt and lowopt None
verbose Verbose output False
veryloose Very loose precision False

Available options for ipsmpi toolchain

option description default
32bit Compile 32bit target False
cciscxx Use CC as CXX False
cstd Specify C standard None
debug Enable debug False
defaultopt Default compiler optimizations False
defaultprec Default precision False
error-unknown-option Error instead of warning for unknown options False
extra_cflags Specify extra CFLAGS options. None
extra_cxxflags Specify extra CXXFLAGS options. None
extra_f90flags Specify extra F90FLAGS options. None
extra_fcflags Specify extra FCFLAGS options. None
extra_fflags Specify extra FFLAGS options. None
i8 Integers are 8 byte integers False
ieee Adhere to IEEE-754 rules False
intel-static Link Intel provided libraries statically False
loose Loose precision False
lowopt Low compiler optimizations False
no-icc Don’t set Intel specific macros False
noopt Disable compiler optimizations False
openmp Enable OpenMP False
opt High compiler optimizations False
optarch Enable architecture optimizations True
packed-linker-options Pack the linker options as comma separated list False
pic Use PIC False
precise High precision False
r8 Real is 8 byte real False
rpath Use RPATH wrappers when –rpath is enabled in EasyBuild configuration True
shared Build shared library False
static Build static library False
strict Strict (highest) precision False
unroll Unroll loops False
usempi Use MPI compiler as default compiler False
vectorize Enable compiler auto-vectorization, default except for noopt and lowopt None
verbose Verbose output False
veryloose Very loose precision False

Available options for iqacml toolchain

option description default
32bit Compile 32bit target False
cciscxx Use CC as CXX False
cstd Specify C standard None
debug Enable debug False
defaultopt Default compiler optimizations False
defaultprec Default precision False
error-unknown-option Error instead of warning for unknown options False
extra_cflags Specify extra CFLAGS options. None
extra_cxxflags Specify extra CXXFLAGS options. None
extra_f90flags Specify extra F90FLAGS options. None
extra_fcflags Specify extra FCFLAGS options. None
extra_fflags Specify extra FFLAGS options. None
i8 Integers are 8 byte integers False
ieee Adhere to IEEE-754 rules False
intel-static Link Intel provided libraries statically False
loose Loose precision False
lowopt Low compiler optimizations False
no-icc Don’t set Intel specific macros False
noopt Disable compiler optimizations False
openmp Enable OpenMP False
opt High compiler optimizations False
optarch Enable architecture optimizations True
packed-linker-options Pack the linker options as comma separated list False
pic Use PIC False
precise High precision False
r8 Real is 8 byte real False
rpath Use RPATH wrappers when –rpath is enabled in EasyBuild configuration True
shared Build shared library False
static Build static library False
strict Strict (highest) precision False
unroll Unroll loops False
usempi Use MPI compiler as default compiler False
vectorize Enable compiler auto-vectorization, default except for noopt and lowopt None
verbose Verbose output False
veryloose Very loose precision False

Available options for ismkl toolchain

option description default
32bit Compile 32bit target False
cciscxx Use CC as CXX False
cstd Specify C standard None
debug Enable debug False
defaultopt Default compiler optimizations False
defaultprec Default precision False
error-unknown-option Error instead of warning for unknown options False
extra_cflags Specify extra CFLAGS options. None
extra_cxxflags Specify extra CXXFLAGS options. None
extra_f90flags Specify extra F90FLAGS options. None
extra_fcflags Specify extra FCFLAGS options. None
extra_fflags Specify extra FFLAGS options. None
i8 Integers are 8 byte integers False
ieee Adhere to IEEE-754 rules False
intel-static Link Intel provided libraries statically False
loose Loose precision False
lowopt Low compiler optimizations False
no-icc Don’t set Intel specific macros False
noopt Disable compiler optimizations False
openmp Enable OpenMP False
opt High compiler optimizations False
optarch Enable architecture optimizations True
packed-linker-options Pack the linker options as comma separated list False
pic Use PIC False
precise High precision False
r8 Real is 8 byte real False
rpath Use RPATH wrappers when –rpath is enabled in EasyBuild configuration True
shared Build shared library False
static Build static library False
strict Strict (highest) precision False
unroll Unroll loops False
usempi Use MPI compiler as default compiler False
vectorize Enable compiler auto-vectorization, default except for noopt and lowopt None
verbose Verbose output False
veryloose Very loose precision False

Available options for nvofbf toolchain

option description default
32bit Compile 32bit target False
cciscxx Use CC as CXX False
cstd Specify C standard None
debug Enable debug False
defaultopt Default compiler optimizations False
defaultprec Default precision False
extra_cflags Specify extra CFLAGS options. None
extra_cxxflags Specify extra CXXFLAGS options. None
extra_f90flags Specify extra F90FLAGS options. None
extra_fcflags Specify extra FCFLAGS options. None
extra_fflags Specify extra FFLAGS options. None
i8 Integers are 8 byte integers False
ieee Adhere to IEEE-754 rules False
loose Loose precision False
lowopt Low compiler optimizations False
noopt Disable compiler optimizations False
openmp Enable OpenMP False
opt High compiler optimizations False
optarch Enable architecture optimizations True
packed-linker-options Pack the linker options as comma separated list False
pic Use PIC False
precise High precision False
r8 Real is 8 byte real False
rpath Use RPATH wrappers when –rpath is enabled in EasyBuild configuration True
shared Build shared library False
static Build static library False
strict Strict (highest) precision False
unroll Unroll loops False
usempi Use MPI compiler as default compiler False
vectorize Enable compiler auto-vectorization, default except for noopt and lowopt None
verbose Verbose output False
veryloose Very loose precision False

Available options for nvompi toolchain

option description default
32bit Compile 32bit target False
cciscxx Use CC as CXX False
cstd Specify C standard None
debug Enable debug False
defaultopt Default compiler optimizations False
defaultprec Default precision False
extra_cflags Specify extra CFLAGS options. None
extra_cxxflags Specify extra CXXFLAGS options. None
extra_f90flags Specify extra F90FLAGS options. None
extra_fcflags Specify extra FCFLAGS options. None
extra_fflags Specify extra FFLAGS options. None
i8 Integers are 8 byte integers False
ieee Adhere to IEEE-754 rules False
loose Loose precision False
lowopt Low compiler optimizations False
noopt Disable compiler optimizations False
openmp Enable OpenMP False
opt High compiler optimizations False
optarch Enable architecture optimizations True
packed-linker-options Pack the linker options as comma separated list False
pic Use PIC False
precise High precision False
r8 Real is 8 byte real False
rpath Use RPATH wrappers when –rpath is enabled in EasyBuild configuration True
shared Build shared library False
static Build static library False
strict Strict (highest) precision False
unroll Unroll loops False
usempi Use MPI compiler as default compiler False
vectorize Enable compiler auto-vectorization, default except for noopt and lowopt None
verbose Verbose output False
veryloose Very loose precision False

Available options for nvompic toolchain

option description default
32bit Compile 32bit target False
cciscxx Use CC as CXX False
cstd Specify C standard None
debug Enable debug False
defaultopt Default compiler optimizations False
defaultprec Default precision False
extra_cflags Specify extra CFLAGS options. None
extra_cxxflags Specify extra CXXFLAGS options. None
extra_f90flags Specify extra F90FLAGS options. None
extra_fcflags Specify extra FCFLAGS options. None
extra_fflags Specify extra FFLAGS options. None
i8 Integers are 8 byte integers False
ieee Adhere to IEEE-754 rules False
loose Loose precision False
lowopt Low compiler optimizations False
noopt Disable compiler optimizations False
openmp Enable OpenMP False
opt High compiler optimizations False
optarch Enable architecture optimizations True
packed-linker-options Pack the linker options as comma separated list False
pic Use PIC False
precise High precision False
r8 Real is 8 byte real False
rpath Use RPATH wrappers when –rpath is enabled in EasyBuild configuration True
shared Build shared library False
static Build static library False
strict Strict (highest) precision False
unroll Unroll loops False
usempi Use MPI compiler as default compiler False
vectorize Enable compiler auto-vectorization, default except for noopt and lowopt None
verbose Verbose output False
veryloose Very loose precision False

Available options for nvpsmpi toolchain

option description default
32bit Compile 32bit target False
cciscxx Use CC as CXX False
cstd Specify C standard None
debug Enable debug False
defaultopt Default compiler optimizations False
defaultprec Default precision False
extra_cflags Specify extra CFLAGS options. None
extra_cxxflags Specify extra CXXFLAGS options. None
extra_f90flags Specify extra F90FLAGS options. None
extra_fcflags Specify extra FCFLAGS options. None
extra_fflags Specify extra FFLAGS options. None
i8 Integers are 8 byte integers False
ieee Adhere to IEEE-754 rules False
loose Loose precision False
lowopt Low compiler optimizations False
noopt Disable compiler optimizations False
openmp Enable OpenMP False
opt High compiler optimizations False
optarch Enable architecture optimizations True
packed-linker-options Pack the linker options as comma separated list False
pic Use PIC False
precise High precision False
r8 Real is 8 byte real False
rpath Use RPATH wrappers when –rpath is enabled in EasyBuild configuration True
shared Build shared library False
static Build static library False
strict Strict (highest) precision False
unroll Unroll loops False
usempi Use MPI compiler as default compiler False
vectorize Enable compiler auto-vectorization, default except for noopt and lowopt None
verbose Verbose output False
veryloose Very loose precision False

Available options for nvpsmpic toolchain

option description default
32bit Compile 32bit target False
cciscxx Use CC as CXX False
cstd Specify C standard None
debug Enable debug False
defaultopt Default compiler optimizations False
defaultprec Default precision False
extra_cflags Specify extra CFLAGS options. None
extra_cxxflags Specify extra CXXFLAGS options. None
extra_f90flags Specify extra F90FLAGS options. None
extra_fcflags Specify extra FCFLAGS options. None
extra_fflags Specify extra FFLAGS options. None
i8 Integers are 8 byte integers False
ieee Adhere to IEEE-754 rules False
loose Loose precision False
lowopt Low compiler optimizations False
noopt Disable compiler optimizations False
openmp Enable OpenMP False
opt High compiler optimizations False
optarch Enable architecture optimizations True
packed-linker-options Pack the linker options as comma separated list False
pic Use PIC False
precise High precision False
r8 Real is 8 byte real False
rpath Use RPATH wrappers when –rpath is enabled in EasyBuild configuration True
shared Build shared library False
static Build static library False
strict Strict (highest) precision False
unroll Unroll loops False
usempi Use MPI compiler as default compiler False
vectorize Enable compiler auto-vectorization, default except for noopt and lowopt None
verbose Verbose output False
veryloose Very loose precision False

Available options for pmkl toolchain

option description default
32bit Compile 32bit target False
cciscxx Use CC as CXX False
cstd Specify C standard None
debug Enable debug False
defaultopt Default compiler optimizations False
defaultprec Default precision False
extra_cflags Specify extra CFLAGS options. None
extra_cxxflags Specify extra CXXFLAGS options. None
extra_f90flags Specify extra F90FLAGS options. None
extra_fcflags Specify extra FCFLAGS options. None
extra_fflags Specify extra FFLAGS options. None
i8 Integers are 8 byte integers False
ieee Adhere to IEEE-754 rules False
loose Loose precision False
lowopt Low compiler optimizations False
noopt Disable compiler optimizations False
openmp Enable OpenMP False
opt High compiler optimizations False
optarch Enable architecture optimizations True
packed-linker-options Pack the linker options as comma separated list False
pic Use PIC False
precise High precision False
r8 Real is 8 byte real False
rpath Use RPATH wrappers when –rpath is enabled in EasyBuild configuration True
shared Build shared library False
static Build static library False
strict Strict (highest) precision False
unroll Unroll loops False
vectorize Enable compiler auto-vectorization, default except for noopt and lowopt None
verbose Verbose output False
veryloose Very loose precision False

Available options for pomkl toolchain

option description default
32bit Compile 32bit target False
cciscxx Use CC as CXX False
cstd Specify C standard None
debug Enable debug False
defaultopt Default compiler optimizations False
defaultprec Default precision False
extra_cflags Specify extra CFLAGS options. None
extra_cxxflags Specify extra CXXFLAGS options. None
extra_f90flags Specify extra F90FLAGS options. None
extra_fcflags Specify extra FCFLAGS options. None
extra_fflags Specify extra FFLAGS options. None
i8 Integers are 8 byte integers False
ieee Adhere to IEEE-754 rules False
loose Loose precision False
lowopt Low compiler optimizations False
noopt Disable compiler optimizations False
openmp Enable OpenMP False
opt High compiler optimizations False
optarch Enable architecture optimizations True
packed-linker-options Pack the linker options as comma separated list False
pic Use PIC False
precise High precision False
r8 Real is 8 byte real False
rpath Use RPATH wrappers when –rpath is enabled in EasyBuild configuration True
shared Build shared library False
static Build static library False
strict Strict (highest) precision False
unroll Unroll loops False
usempi Use MPI compiler as default compiler False
vectorize Enable compiler auto-vectorization, default except for noopt and lowopt None
verbose Verbose output False
veryloose Very loose precision False

Available options for pompi toolchain

option description default
32bit Compile 32bit target False
cciscxx Use CC as CXX False
cstd Specify C standard None
debug Enable debug False
defaultopt Default compiler optimizations False
defaultprec Default precision False
extra_cflags Specify extra CFLAGS options. None
extra_cxxflags Specify extra CXXFLAGS options. None
extra_f90flags Specify extra F90FLAGS options. None
extra_fcflags Specify extra FCFLAGS options. None
extra_fflags Specify extra FFLAGS options. None
i8 Integers are 8 byte integers False
ieee Adhere to IEEE-754 rules False
loose Loose precision False
lowopt Low compiler optimizations False
noopt Disable compiler optimizations False
openmp Enable OpenMP False
opt High compiler optimizations False
optarch Enable architecture optimizations True
packed-linker-options Pack the linker options as comma separated list False
pic Use PIC False
precise High precision False
r8 Real is 8 byte real False
rpath Use RPATH wrappers when –rpath is enabled in EasyBuild configuration True
shared Build shared library False
static Build static library False
strict Strict (highest) precision False
unroll Unroll loops False
usempi Use MPI compiler as default compiler False
vectorize Enable compiler auto-vectorization, default except for noopt and lowopt None
verbose Verbose output False
veryloose Very loose precision False

Available options for system toolchain

option description default
32bit Compile 32bit target False
cciscxx Use CC as CXX False
cstd Specify C standard None
debug Enable debug False
defaultopt Default compiler optimizations False
defaultprec Default precision False
extra_cflags Specify extra CFLAGS options. None
extra_cxxflags Specify extra CXXFLAGS options. None
extra_f90flags Specify extra F90FLAGS options. None
extra_fcflags Specify extra FCFLAGS options. None
extra_fflags Specify extra FFLAGS options. None
i8 Integers are 8 byte integers False
ieee Adhere to IEEE-754 rules False
loose Loose precision False
lowopt Low compiler optimizations False
noopt Disable compiler optimizations False
openmp Enable OpenMP False
opt High compiler optimizations False
optarch Enable architecture optimizations True
packed-linker-options Pack the linker options as comma separated list False
pic Use PIC False
precise High precision False
r8 Real is 8 byte real False
rpath Use RPATH wrappers when –rpath is enabled in EasyBuild configuration True
shared Build shared library False
static Build static library False
strict Strict (highest) precision False
unroll Unroll loops False
vectorize Enable compiler auto-vectorization, default except for noopt and lowopt None
verbose Verbose output False
veryloose Very loose precision False

Available options for xlcxlf toolchain

option description default
32bit Compile 32bit target False
cciscxx Use CC as CXX False
cstd Specify C standard None
debug Enable debug False
defaultopt Default compiler optimizations False
defaultprec Default precision False
error-unknown-option Error instead of warning for unknown options False
extra_cflags Specify extra CFLAGS options. None
extra_cxxflags Specify extra CXXFLAGS options. None
extra_f90flags Specify extra F90FLAGS options. None
extra_fcflags Specify extra FCFLAGS options. None
extra_fflags Specify extra FFLAGS options. None
i8 Integers are 8 byte integers False
ibm-static Link IBM XL provided libraries statically False
ieee Adhere to IEEE-754 rules False
loose Loose precision False
lowopt Low compiler optimizations False
noopt Disable compiler optimizations False
openmp Enable OpenMP False
opt High compiler optimizations False
optarch Enable architecture optimizations True
packed-linker-options Pack the linker options as comma separated list False
pic Use PIC False
precise High precision False
r8 Real is 8 byte real False
rpath Use RPATH wrappers when –rpath is enabled in EasyBuild configuration True
shared Build shared library False
static Build static library False
strict Strict (highest) precision False
unroll Unroll loops False
vectorize Enable compiler auto-vectorization, default except for noopt and lowopt None
verbose Verbose output False
veryloose Very loose precision False

Available options for xlmpich2 toolchain

option description default
32bit Compile 32bit target False
cciscxx Use CC as CXX False
cstd Specify C standard None
debug Enable debug False
defaultopt Default compiler optimizations False
defaultprec Default precision False
error-unknown-option Error instead of warning for unknown options False
extra_cflags Specify extra CFLAGS options. None
extra_cxxflags Specify extra CXXFLAGS options. None
extra_f90flags Specify extra F90FLAGS options. None
extra_fcflags Specify extra FCFLAGS options. None
extra_fflags Specify extra FFLAGS options. None
i8 Integers are 8 byte integers False
ibm-static Link IBM XL provided libraries statically False
ieee Adhere to IEEE-754 rules False
loose Loose precision False
lowopt Low compiler optimizations False
noopt Disable compiler optimizations False
openmp Enable OpenMP False
opt High compiler optimizations False
optarch Enable architecture optimizations True
packed-linker-options Pack the linker options as comma separated list False
pic Use PIC False
precise High precision False
r8 Real is 8 byte real False
rpath Use RPATH wrappers when –rpath is enabled in EasyBuild configuration True
shared Build shared library False
static Build static library False
strict Strict (highest) precision False
unroll Unroll loops False
usempi Use MPI compiler as default compiler False
vectorize Enable compiler auto-vectorization, default except for noopt and lowopt None
verbose Verbose output False
veryloose Very loose precision False

Available options for xlmpich toolchain

option description default
32bit Compile 32bit target False
cciscxx Use CC as CXX False
cstd Specify C standard None
debug Enable debug False
defaultopt Default compiler optimizations False
defaultprec Default precision False
error-unknown-option Error instead of warning for unknown options False
extra_cflags Specify extra CFLAGS options. None
extra_cxxflags Specify extra CXXFLAGS options. None
extra_f90flags Specify extra F90FLAGS options. None
extra_fcflags Specify extra FCFLAGS options. None
extra_fflags Specify extra FFLAGS options. None
i8 Integers are 8 byte integers False
ibm-static Link IBM XL provided libraries statically False
ieee Adhere to IEEE-754 rules False
loose Loose precision False
lowopt Low compiler optimizations False
noopt Disable compiler optimizations False
openmp Enable OpenMP False
opt High compiler optimizations False
optarch Enable architecture optimizations True
packed-linker-options Pack the linker options as comma separated list False
pic Use PIC False
precise High precision False
r8 Real is 8 byte real False
rpath Use RPATH wrappers when –rpath is enabled in EasyBuild configuration True
shared Build shared library False
static Build static library False
strict Strict (highest) precision False
unroll Unroll loops False
usempi Use MPI compiler as default compiler False
vectorize Enable compiler auto-vectorization, default except for noopt and lowopt None
verbose Verbose output False
veryloose Very loose precision False

Available options for xlmvapich2 toolchain

option description default
32bit Compile 32bit target False
cciscxx Use CC as CXX False
cstd Specify C standard None
debug Enable debug False
defaultopt Default compiler optimizations False
defaultprec Default precision False
error-unknown-option Error instead of warning for unknown options False
extra_cflags Specify extra CFLAGS options. None
extra_cxxflags Specify extra CXXFLAGS options. None
extra_f90flags Specify extra F90FLAGS options. None
extra_fcflags Specify extra FCFLAGS options. None
extra_fflags Specify extra FFLAGS options. None
i8 Integers are 8 byte integers False
ibm-static Link IBM XL provided libraries statically False
ieee Adhere to IEEE-754 rules False
loose Loose precision False
lowopt Low compiler optimizations False
noopt Disable compiler optimizations False
openmp Enable OpenMP False
opt High compiler optimizations False
optarch Enable architecture optimizations True
packed-linker-options Pack the linker options as comma separated list False
pic Use PIC False
precise High precision False
r8 Real is 8 byte real False
rpath Use RPATH wrappers when –rpath is enabled in EasyBuild configuration True
shared Build shared library False
static Build static library False
strict Strict (highest) precision False
unroll Unroll loops False
usempi Use MPI compiler as default compiler False
vectorize Enable compiler auto-vectorization, default except for noopt and lowopt None
verbose Verbose output False
veryloose Very loose precision False

Available options for xlompi toolchain

option description default
32bit Compile 32bit target False
cciscxx Use CC as CXX False
cstd Specify C standard None
debug Enable debug False
defaultopt Default compiler optimizations False
defaultprec Default precision False
error-unknown-option Error instead of warning for unknown options False
extra_cflags Specify extra CFLAGS options. None
extra_cxxflags Specify extra CXXFLAGS options. None
extra_f90flags Specify extra F90FLAGS options. None
extra_fcflags Specify extra FCFLAGS options. None
extra_fflags Specify extra FFLAGS options. None
i8 Integers are 8 byte integers False
ibm-static Link IBM XL provided libraries statically False
ieee Adhere to IEEE-754 rules False
loose Loose precision False
lowopt Low compiler optimizations False
noopt Disable compiler optimizations False
openmp Enable OpenMP False
opt High compiler optimizations False
optarch Enable architecture optimizations True
packed-linker-options Pack the linker options as comma separated list False
pic Use PIC False
precise High precision False
r8 Real is 8 byte real False
rpath Use RPATH wrappers when –rpath is enabled in EasyBuild configuration True
shared Build shared library False
static Build static library False
strict Strict (highest) precision False
unroll Unroll loops False
usempi Use MPI compiler as default compiler False
vectorize Enable compiler auto-vectorization, default except for noopt and lowopt None
verbose Verbose output False
veryloose Very loose precision False