DPCPP(1)

The Intel(R) oneAPI DPC++ Compiler is based on open source LLVM* compiler technology.

The dpcpp driver is deprecated and will be removed in a future release. Please use icpx -fsycl or icx-cl -fsycl.

This man page describes the supported options for Intel(R) oneAPI DPC++ (Data Parallel C++).

NOTE: macOS* is not supported for this product.

dpcpp - invokes the Intel(R) oneAPI DPC++ Compiler

SYNOPSIS

To invoke the Intel(R) oneAPI DPC++ Compiler:

dpcpp [options] file1 [file2 ...]

where:

•   options represents zero or more compiler options.

•   fileN represents a C/C++ source (.C, .c, .cc, .cp, .cpp, .cxx, .c++, .i), assembly (.s), object (.o), static library (.a), or other linkable file.

For information about available SYCL drivers, refer to topic Invoke the Compiler in the Intel(R) oneAPI DPC++/C++ Compiler Developer Guide and Reference.

DESCRIPTION

The Intel(R) oneAPI DPC++ Compiler is designed to process C++ and C programs on Intel(R) 64 architecture-based systems.

This man page is intended for Linux* users.

You may see some options labeled as experimental features. An experimental feature is one that requires further testing and possible refinement. Depending on testing results, such features may be fully defined and implemented or they may be removed in a future release.

Some text in the option descriptions may show shortcut names used in the Developer and Reference Guide. In that document, the shortcuts are used to avoid spelling out option syntax for different operating systems.

You may see either or both of the following shortcuts:

•   If you see [Q]option-name, it means that the Linux name of the option is what appears following [Q]. For example, if you see [Q]ipo, the Linux form of the option is -ipo.

•   If you see [q or Q]option-name, it means that the Linux name of the option starts with a q. For example, if you see [q or Q]opt-report, the Linux form of the option is -qopt-report.

Otherwise, Linux* compiler option names are shown with an initial "-".

  Clang Option Support

Clang compiler options are supported for this compiler. We do not document these options, but you can check dpcpp -help on the command line to see if a particular option is supported. For more information about Clang options, see https://clang.llvm.org/docs/ClangCommandLineReference.html.

FEATURE REQUIREMENTS

The following lists dependent features and their corresponding required products. For certain compiler options, the compilation may fail if the option is specified but the required product is not installed. In this case, remove the option from the command line and recompile.

•   Feature: -qtbb, -tbb, and /Qtbb options Requirement: Intel(R) oneAPI Threading Building Blocks (oneTBB) installation

•   Feature: -mkl, -qmkl, -qmkl-ilp64, /Qmkl and /Qmkl-ilp64 options Requirement: Intel(R) oneAPI Math Kernel Library (oneMKL) installation

•   Feature: -daal, -qdaal, and /Qdaal options Requirement: Intel(R) oneAPI Data Analytics Library (oneDAL) installation

•   Feature: -ipp, -qipp, and /Qipp options Requirement: Intel(R) Integrated Performance Primitives (Intel(R) IPP) installation

•   Feature: Use crypto to link to the Intel(R) IPP Cryptography library Requirement: Intel(R) Integrated Performance Primitives Cryptography (Intel(R) IPP Cryptography) installation

•   Feature: Thread Checking Requirement: Intel(R) Inspector installation

•   Feature: Trace Analyzing and Collecting Requirement: Intel(R) Trace Analyzer and Collector installation Compiler options related to this feature may require a set-up script. For further information, see the product documentation.

OPTIONS

This section contains descriptions of available compiler options. The options are listed in alphabetical order.

NOTE: Currently, macOS* is not supported for this product.

-ansi (L*X only)

    Enables language compatibility with the
        gcc option ansi.

    Arguments:

    None

    Default:

    OFF GNU C++ is more strongly supported than ANSI C.

    Description:

    This option enables language compatibility with the gcc option -ansi and provides the same level of ANSI standard conformance as that option.

    If you want strict ANSI conformance, use the -strict-ansi option.

    Alternate Options:

    None

-axcode (L*X only)

    Tells the compiler to generate multiple,
        feature-specific auto-dispatch code paths for Intel(R) processors if there is a performance benefit.

    Arguments:

    code
        Indicates to the compiler a feature set that it may target, including which instruction sets it may generate. The following descriptions refer to Intel(R) Streaming SIMD Extensions (Intel(R) SSE) and Supplemental Streaming SIMD Extensions (SSSE). Possible values are:

        ALDERLAKE AMBERLAKE BROADWELL CANNONLAKE CASCADELAKE COFFEELAKE COOPERLAKE GOLDMONT
            GOLDMONT-PLUS HASWELL ICELAKE-CLIENT (or ICELAKE) ICELAKE-SERVER IVYBRIDGE KABYLAKE ROCKETLAKE SANDYBRIDGE SAPPHIRERAPIDS SILVERMONT SKYLAKE SKYLAKE-AVX512 TIGERLAKE TREMONT WHISKEYLAKE May generate instructions for processors that support the specified Intel(R) processor or microarchitecture code name.

            Keyword ICELAKE is deprecated and may be removed in a future release.

        COMMON-AVX512
            May generate Intel(R) Advanced Vector Extensions 512 (Intel(R) AVX-512) Foundation instructions, Intel(R) AVX-512 Conflict Detection Instructions (CDI), as well as the instructions enabled with CORE-AVX2.

        CORE-AVX512
            May generate Intel(R) Advanced Vector Extensions 512 (Intel(R) AVX-512) Foundation instructions, Intel(R) AVX-512 Conflict Detection Instructions (CDI), Intel(R) AVX-512 Doubleword and Quadword Instructions (DQI), Intel(R) AVX-512 Byte and Word Instructions (BWI) and Intel(R) AVX-512 Vector Length extensions, as well as the instructions enabled with CORE-AVX2.

        CORE-AVX2
            May generate Intel(R) Advanced Vector Extensions 2 (Intel(R) AVX2), Intel(R) AVX, SSE4.2, SSE4.1, SSE3, SSE2, SSE, and SSSE3 instructions for Intel(R) processors.

        CORE-AVX-I
            May generate Float-16 conversion instructions and the RDRND instruction, Intel(R) Advanced Vector Extensions (Intel(R) AVX), Intel(R) SSE4.2, SSE4.1, SSE3, SSE2, SSE, and SSSE3 instructions for Intel(R) processors.

        AVX May generate Intel(R) Advanced Vector Extensions (Intel(R) AVX), Intel(R) SSE4.2, SSE4.1, SSE3, SSE2, SSE, and SSSE3 instructions for Intel(R) processors.

        SSE4.2
            May generate Intel(R) SSE4.2, SSE4.1, SSE3, SSE2, SSE, and SSSE3 instructions for Intel processors.

        SSE4.1
            May generate Intel(R) SSE4.1, SSE3, SSE2, SSE, and SSSE3 instructions for Intel(R) processors.

        SSSE3
            May generate SSSE3 instructions and Intel(R) SSE3, SSE2, and SSE instructions for Intel(R) processors.

        SSE3
            May generate Intel(R) SSE3, SSE2, and SSE instructions for Intel(R) processors.

    You can specify more than one code value. When specifying more than one code value, each value must be separated with a comma. See the Examples section below.

    Default:

    OFF No auto-dispatch code is generated. Feature-specific code is generated and is controlled by the setting of the following compiler options:

        •   Linux*: -march and -x

    Description:

    This option tells the compiler to generate multiple, feature-specific auto-dispatch code paths for Intel(R) processors if there is a performance benefit. It also generates a baseline code path. The Intel feature-specific auto-dispatch path is usually more optimized than the baseline path. Other options, such as O3, control how much optimization is performed on the baseline path.

    The baseline code path is determined by the architecture specified by options -march or -x (Linux*) or options /arch or /Qx (Windows*). While there are defaults for the [Q]x option that depend on the operating system being used, you can specify an architecture and optimization level for the baseline code that is higher or lower than the default. The specified architecture becomes the effective minimum architecture for the baseline code path.

    If you specify both the [Q]ax and [Q]x options, the baseline code will only execute on Intel(R) processors compatible with the setting specified for the [Q]x.

    If you specify both the -ax and -march options (Linux) or the /Qax and /arch options (Windows), the baseline code will execute on non-Intel(R) processors compatible with the setting specified for the -march or /arch option.

    A Non-Intel(R) baseline and an Intel(R) baseline have the same set of optimizations enabled, and the default for both is SSE4.2 for x86-based architectures.

    The [Q]ax option tells the compiler to find opportunities to generate separate versions of functions that take advantage of features of the specified instruction features.

    If the compiler finds such an opportunity, it first checks whether generating a feature-specific version of a function is likely to result in a performance gain. If this is the case, the compiler generates both a feature-specific version of a function and a baseline version of the function. At runtime, one of the versions is chosen to execute, depending on the Intel(R) processor in use. In this way, the program can benefit from performance gains on more advanced Intel processors, while still working properly on older processors and non-Intel processors. A non-Intel processor always executes the baseline code path.

    You can use more than one of the feature values by combining them. For example, you can specify -axSSE4.1,SSSE3 (Linux) or /QaxSSE4.1,SSSE3 (Windows).

    NOTE: This option only applies to host compilation. When offloading is enabled, it does not impact device-specific compilation.

    NOTE: When using the icx compiler, if you experience any program failure when using option -ax during this release, please remove the option to see if that solves the problem. If that action solved the problem, please report a bug.

    Alternate Options:

    None

-Bdir (L*X only)

    Specifies a directory that can be used to
        find include files, libraries, and executables.

    Arguments:

    dir Is the directory to be used. If necessary, the compiler adds a directory separator character at the end of dir.

    Default:

    OFF The compiler looks for files in the directories specified in your PATH environment variable.

    Description:

    This option specifies a directory that can be used to find include files, libraries, and executables.

    The compiler uses dir as a prefix.

    For include files, the dir is converted to -I/dir/include. This command is added to the front of the includes passed to the preprocessor.

    For libraries, the dir is converted to -L/dir. This command is added to the front of the standard -L inclusions before system libraries are added.

    For executables, if dir contains the name of a tool, such as ld or as, the compiler will use it instead of those found in the default directories.

    The compiler looks for include files in dir /include while library files are looked for in dir.

    On Linux* systems, another way to get the behavior of this option is to use the environment variable GCC_EXEC_PREFIX.

    Alternate Options:

    None

-c (L*X only)

    Causes the compiler to generate an object
        only and not link.

    Arguments:

    None

    Default:

    OFF Linking is performed.

    Description:

    This option causes the compiler to generate an object only and not link. Compilation stops after the object file is generated.

    The compiler generates an object file for each C or C++ source file or preprocessed source file. It also takes an assembler file and invokes the assembler to generate an object file.

-C (L*X only)

    Places comments in preprocessed source
        output.

    Arguments:

    None

    Default:

    OFF No comments are placed in preprocessed source output.

    Description:

    This option places (or preserves) comments in preprocessed source output.

    Comments following preprocessing directives, however, are not preserved.

    Alternate Options:

    None

-Dname[=value] (L*X only)

    Defines a
        macro name that can be associated with an optional value.

    Arguments:

    name
        Is the name of the macro.

    value
        Is an optional integer or an optional character string delimited by double quotes; for example, Dname=string.

    Default:

    OFF Only default symbols or macros are defined.

    Description:

    Defines a macro name that can be associated with an optional value. This option is equivalent to a #define preprocessor directive.

    If a value is not specified, name  is defined as "1".

    Alternate Options:

    None

-dD (L*X only)

    Same as option -dM, but outputs #define
        directives in preprocessed source.

    Arguments:

    None

    Default:

    OFF The compiler does not output #define directives.

    Description:

    Same as -dM, but outputs #define directives in preprocessed source. To use this option, you must also specify the E option.

    Alternate Options:

    None

-debug[=keyword] (L*X only)

    Enables or disables generation of
        debugging information.

    Arguments:

    keyword
        Is the type of debugging information to be generated. Possible values are:

        none
            Disables generation of debugging information.

        full or
            all Generates complete debugging information.

        minimal
            Generates line number information for debugging.

        emit-column
            Generates column number information for debugging.

        [no]expr-source-pos
            Determines whether the compiler generates source position information at the expression level of granularity.

        [no]inline-debug-info
            Determines whether the compiler generates enhanced debug information for inlined code.

        [no]variable-locations
            Determines whether the compiler generates enhanced debug information useful in finding scalar local variables.

        extended
            Generates complete debugging information and also sets keyword values semantic-stepping and variable-locations.

        [no]parallel  (Linux only)
            Determines whether the compiler generates parallel debug code instrumentations useful for thread data sharing and reentrant call detection.

    For information on the non-default settings for these keywords, see the Description section.

    Default:

    varies
        Normally, the default is -debug none and no debugging information is generated. However, on Linux*, the -debug inline-debug-info option will be enabled by default if you compile with optimizations (option -O2 or higher) and debugging is enabled (option -g).

    Description:

    This option enables or disables generation of debugging information.

    By default, enabling debugging, will disable optimization. To enable both debugging and optimization use the -debug option together with one of the optimization level options (-O3, -O2 or -O3).

    Keywords inline-debug-info, variable-locations, and extended can be used in combination with each other. If conflicting keywords are used in combination, the last one specified on the command line has precedence.

    Option
        Description

    -debug none
        Disables generation of debugging information.

    -debug full or
        -debug all Generates complete debugging information. It is the same as specifying -debug with no keyword.

    -debug minimal
        Generates line number information for debugging.

    -debug expr-source-pos
        Generates source position information at the statement level of granularity.

    -debug inline-debug-info
        Generates enhanced debug information for inlined code.

    On inlined functions, symbols are (by default) associated with the
        caller. This option causes symbols for inlined functions to be associated with the source of the called function.

    -debug variable-locations
        Generates enhanced debug information useful in finding scalar local variables. It uses a feature of the Dwarf object module known as "location lists".

    This feature allows the runtime locations of
        local scalar variables to be specified more accurately; that is, whether, at a given position in the code, a variable value is found in memory or a machine register.

    -debug extended
        Sets keyword variable-locations. It also tells the compiler to include column numbers in the line information.

    Generates complete debugging information. This
        is a more powerful setting than -debug full or -debug all.

    -debug parallel
        Generates parallel debug code instrumentations needed for the thread data sharing and reentrant call detection.

    For shared data and reentrancy
        detection, option -qopenmp must be set.

    On Linux* systems, debuggers read debug information from
        executable images. As a result, information is written to object files and then added to the executable by the linker.

    Alternate Options:

    For -debug full, -debug all, or -debug Linux: -g

-device-math-lib=library (L*X only)

-no-device-math-lib=library (L*X only)

    Enables or disables certain device
        libraries. This is a deprecated option that may be removed in a future release.

    Arguments:

    library
        Possible values are:

        fp32
            Links the fp32 device math library.

        fp64
            Links the fp64 device math library.

        To link more than one library, include a comma between the library names.

        For example, if you want to link both the fp32 and fp64 device libraries, specify: fp32, fp64

    Default:

    fp32, fp64
        Both the fp32 and fp64 device libraries are linked.

    Description:

    This option enables or disables certain device libraries.

    This is a deprecated option that may be removed in a future release. There is no replacement option.

    Alternate Options:

    None

-dM (L*X only)

    Tells the compiler to output macro
        definitions in effect after preprocessing.

    Arguments:

    None

    Default:

    OFF The compiler does not output macro definitions after preprocessing.

    Description:

    This option tells the compiler to output macro definitions in effect after preprocessing. To use this option, you must also specify option E.

    Alternate Options:

    None

-dryrun (L*X only)

    Specifies that driver tool commands
        should be shown but not executed.

    Arguments:

    None

    Default:

    OFF No tool commands are shown, but they are executed.

    Description:

    This option specifies that driver tool commands should be shown but not executed.

    Alternate Options:

    None

-dumpmachine (L*X only)

    Displays the target machine and operating
        system configuration.

    Arguments:

    None

    Default:

    OFF The compiler does not display target machine or operating system information.

    Description:

    This option displays the target machine and operating system configuration. No compilation is performed.

    NOTE: This option only applies to host compilation. When offloading is enabled, it does not impact device-specific compilation.

    Alternate Options:

    None

-dumpversion (L*X only)

    Displays the version number of the
        compiler.

    Arguments:

    None

    Default:

    OFF The compiler does not display the compiler version number.

    Description:

    This option displays the version number of the compiler. It does not compile your source files.

    NOTE: This option only applies to host compilation. When offloading is enabled, it does not impact device-specific compilation.

    Alternate Options:

    None

-E (L*X only)

    Causes the preprocessor to send output to
        stdout.

    Arguments:

    None

    Default:

    OFF Preprocessed source files are output to the compiler.

    Description:

    This option causes the preprocessor to send output to stdout. Compilation stops when the files have been preprocessed.

    When you specify this option, the compiler's preprocessor expands your source module and writes the result to stdout. The preprocessed source contains #line directives, which the compiler uses to determine the source file and line number.

    Alternate Options:

    None

-EP (L*X only)

    Causes the preprocessor to send output to
        stdout, omitting #line directives.

    Arguments:

    None

    Default:

    OFF Preprocessed source files are output to the compiler.

    Description:

    This option causes the preprocessor to send output to stdout, omitting #line directives.

    If you also specify option P or Linux* option F, the preprocessor will write the results (without #line directives) to a file instead of stdout.

    Alternate Options:

    None

-fasm-blocks (L*X only)

    Enables the use of blocks and entire
        functions of assembly code within a C or C++ file.

    Arguments:

    None

    Default:

    OFF The compiler allows a GNU*-style inline assembly format.

    Description:

    This option enables the use of blocks and entire functions of assembly code within a C or C++ file.

    It allows a Microsoft* MASM-style inline assembly block not a GNU*-style inline assembly block.

    NOTE: This option only applies to host compilation. When offloading is enabled, it does not impact device-specific compilation.

    Alternate Options:

    -use-msasm

-fast (L*X only)

    Maximizes speed across the entire
        program.

    Arguments:

    None

    Default:

    OFF The optimizations that maximize speed are not enabled.

    Description:

    This option maximizes speed across the entire program.

    Linux

    It sets the following options:

    -ipo, -O3, -static

    Windows

    It sets the following options:

    /O3, /Qipo, /Qprec-div-, /fp:fast=2

    NOTE: Option fast sets some aggressive optimizations that may not be appropriate for all applications. The resulting executable may not run on processor types different from the one on which you compile. You should make sure that you understand the individual optimization options that are enabled by option fast.

    NOTE: This option only applies to host compilation. When offloading is enabled, it does not impact device-specific compilation.

    Product and Performance Information

    = = = = = = = = = =

    Performance varies by use, configuration and other factors. Learn more at
        www.Intel.com/PerformanceIndex.

    Notice revision #20201201

    = = = = = = = = = =

    Alternate Options:

    None

-fasynchronous-unwind-tables (L*X only)

-fno-asynchronous-unwind-tables (L*X only)

    Determines whether unwind information is
        precise at an instruction boundary or at a call boundary.

    Arguments:

    None

    Default:

    -fasynchronous-unwind-tables
        The unwind table generated is precise at an instruction boundary, enabling accurate unwinding at any instruction.

    Description:

    This option determines whether unwind information is precise at an instruction boundary or at a call boundary. The compiler generates an unwind table in DWARF2 or DWARF3 format, depending on which format is supported on your system.

    If -fno-asynchronous-unwind-tables is specified, the unwind table is precise at call boundaries only. In this case, the compiler will avoid creating unwind tables for routines such as the following:

    •   A C++ routine that does not declare objects with destructors and does not contain calls to routines that might throw an exception.

    •   A C/C++ or Fortran routine compiled without -fexceptions and without -traceback.

    •   A C/C++ or Fortran routine compiled with -fexceptions that does not contain calls to routines that might throw an exception.

    Alternate Options:

    None

-fbuiltin[-name] (L*X only)

-fno-builtin[-name] (L*X only)

    Enables or disables inline expansion of
        intrinsic functions.

    Arguments:

    name
        Is a list of one or more intrinsic functions. If there is more than one intrinsic function, they must be separated by commas.

    Default:

    ON  Inline expansion of intrinsic functions is enabled.

    Description:

    This option enables or disables inline expansion of one or more intrinsic functions.

    If -fno-builtin-name or /Qno-builtin-name is specified, inline expansion is disabled for the named functions. If name is not specified, -fno-builtin or /Oi- disables inline expansion for all intrinsic functions.

    For a list of built-in functions affected by -fbuiltin, search for "built-in functions" in the appropriate gcc* documentation.

    For a list of built-in functions affected by /Oi, search for "/Oi" in the appropriate Microsoft* Visual C/C++* documentation.

    Alternate Options:

    None

-fcf-protection[=keyword] (L*X only)

    Enables Intel(R) Control-Flow Enforcement
        Technology (Intel(R) CET) protection, which defends your program from certain attacks that exploit vulnerabilities. This option offers preliminary support for Intel(R) CET.

    Arguments:

    keyword
        Specifies the level of protection the compiler should perform. Possible values are:

        return
            Enables shadow stack protection.

        branch
            Enables endbranch (EB) generation.

        full
            Enables shadow stack protection and endbranch (EB) generation.

            This is the same as specifying this compiler option with no keyword.

        none
            Disables Intel(R) CET protection.

    Default:

    -fcf-protection=none or
        /Qcf-protection:none No Control-flow Enforcement protection is performed.

    Description:

    This option enables Intel(R) CET protection, which defends your program from certain attacks that exploit vulnerabilities.

    Intel(R) CET protections are enforced on processors that support Intel(R) CET. They are ignored on processors that do not support Intel(R) CET, so they are safe to use in programs that might run on a variety of processors.

    Shadow stack protection helps to protect your program from return-oriented programming (ROP). Return-oriented programming (ROP) is a technique to exploit computer security defenses such as non-executable memory and code signing by gaining control of the call stack to modify program control flow and then execute certain machine instruction sequences.

    Endbranch (EB) generation helps to protect your program from call/jump-oriented programming (COP/JOP). Jump-oriented programming (JOP) is a variant of ROP that uses indirect jumps and calls to emulate return instructions. Call-oriented programming (COP) is a variant of ROP that employs indirect calls.

    NOTE: This option only applies to host compilation. When offloading is enabled, it does not impact device-specific compilation.

    Alternate Options:

    Linux: -qcf-protection

    Windows: None

-fcommon (L*X only)

-fno-common (L*X only)

    Determines whether the compiler treats
        common symbols as global definitions.

    Arguments:

    None

    Default:

    -fcommon
        The compiler does not treat common symbols as global definitions.

    Description:

    This option determines whether the compiler treats common symbols as global definitions and to allocate memory for each symbol at compile time.

    Option -fno-common tells the compiler to treat common symbols as global definitions. When using this option, you can only have a common variable declared in one module; otherwise, a link time error will occur for multiple defined symbols.

    Normally, a file-scope declaration with no initializer and without the extern or static keyword "int i;" is represented as a common symbol. Such a symbol is treated as an external reference. However, if no other compilation unit has a global definition for the name, the linker allocates memory for it.

    Alternate Options:

    None

-fdata-sections (L*X only)

    Places each data item in its own COMDAT
        section.

    Arguments:

    None

    Default:

    OFF The compiler does not separate functions into COMDATs.

    Description:

    This option places each data item in its own COMDAT section.

    When using this compiler option, you can add the linker option -Wl,--gc-sections (LInux) or /link /OPT:REF (Windows), which will remove all unused code.

    NOTE: When you put each data item in its own section, it enables the linker to reorder the sections for other possible optimization.

    Alternate Options:

    None

-fexceptions (L*X only)

-fno-exceptions (L*X only)

    Enables exception handling table
        generation.

    Arguments:

    None

    Default:

    -fexceptions
        Exception handling table generation is enabled. Default for C++.

    -fno-exceptions
        Exception handling table generation is disabled. Default for C.

    Description:

    This option enables exception handling table generation. The -fno-exceptions option disables exception handling table generation, resulting in smaller code. When this option is used, any use of exception handling constructs (such as try blocks and throw statements) will produce an error. Exception specifications are parsed but ignored. It also undefines the preprocessor symbol __EXCEPTIONS.

    Alternate Options:

    None

-ffp-contract=keyword (L*X only)

    Controls when the compiler is permitted
        to form fused floating-point operations, such as fused multiply-add (FMA). Fused operations are allowed to produce more precise results than performing the individual operations separately.

    Arguments:

    keyword
        Possible values are:

        fast
            Fuses floating-point operations across statements.

        on  Fuses floating-point operations within the same statement.

        off Does not fuse floating-point operations.

    Default:

    -ffp-contract=fast
        Fuses floating-point operations across statements.

        However, if option -fp-model=strict is specified, the default is -ffp-contract=off.

    Description:

    This option controls when the compiler is permitted to form fused floating-point operations, such as fused multiply-add (FMA). Fused operations are allowed to produce more precise results than performing the individual operations separately.

    Alternate Options:

    None

-ffreestanding (L*X only)

    Ensures that compilation takes place in a
        freestanding environment.

    Arguments:

    None

    Default:

    OFF Standard libraries are used during compilation.

    Description:

    This option ensures that compilation takes place in a freestanding environment. The compiler assumes that the standard library may not exist and program startup may not necessarily be at main. This environment meets the definition of a freestanding environment as described in the C and C++ standard.

    An example of an application requiring such an environment is an OS kernel.

    NOTE: When you specify this option, the compiler will not assume the presence of compiler-specific libraries. It will only generate calls that appear in the source code.

    NOTE: This option only applies to host compilation. When offloading is enabled, it does not impact device-specific compilation.

    Alternate Options:

    None

-ffunction-sections (L*X only)

    Places each function in its own COMDAT
        section.

    Arguments:

    None

    Default:

    OFF The compiler does not separate functions into COMDATs.

    Description:

    This option places each function in its own COMDAT section.

    When using this compiler option, you can add the linker option -Wl,--gc-sections (Linux) or /link /OPT:REF (Windows), which will remove all unused code.

    NOTE: When you put each function in its own section, it enables the linker to reorder the sections for other possible optimization.

    Alternate Options:

    None

-fgnu89-inline (L*X only)

    Tells the compiler to use C89 semantics
        for inline functions when in C99 mode.

    Arguments:

    None

    Default:

    OFF

    Description:

    This option tells the compiler to use C89 semantics for inline functions when in C99 mode.

    Alternate Options:

    None

-fimf-absolute-error=value[:funclist] (L*X only)

    Defines the maximum allowable absolute
        error for math library function results.

    Arguments:

    value
        Is a positive, floating-point number. Errors in math library function results may exceed the maximum relative error (max-error) setting if the absolute-error is less than or equal to value.

        The format for the number is [digits] [.digits] [ { e | E }[sign]digits]

    funclist
        Is an optional list of one or more math library functions to which the attribute should be applied. If you specify more than one function, they must be separated with commas.

        Precision-specific variants like sin and sinf are considered different functions, so you would need to use -fimf-absolute-error=0.00001:sin,sinf (or /Qimf-absolute-error:0.00001:sin,sinf) to specify the maximum allowable absolute error for both the single-precision and double-precision sine functions.

        You also can specify the symbol /f to denote single-precision divides, symbol / to denote double-precision divides, symbol /l to denote extended-precision divides, and symbol /q to denote quad-precision divides. For example you can specify -fimf-absolute-error=0.00001:/ or /Qimf-absolute-error: 0.00001:/.

    Default:

    Zero ("0")
        An absolute-error setting of 0 means that the function is bound by the relative error setting. This is the default behavior.

    Description:

    This option defines the maximum allowable absolute error for math library function results.

    This option can improve runtime performance, but it may decrease the accuracy of results.

    This option only affects functions that have zero as a possible return value, such as log, sin, asin, etc.

    The relative error requirements for a particular function are determined by options that set the maximum relative error (max-error) and precision. The return value from a function must have a relative error less than the max-error value, or an absolute error less than the absolute-error value.

    If you need to define the accuracy for a math function of a certain precision, specify the function name of the precision that you need. For example, if you want double precision, you can specify :sin; if you want single precision, you can specify :sinf, as in -fimf-absolute-error=0.00001:sin or /Qimf-absolute-error:0.00001:sin, or -fimf-absolute-error=0.00001:sqrtf or /Qimf-absolute-error:0.00001:sqrtf.

    If you do not specify any function names, then the setting applies to all functions (and to all precisions). However, as soon as you specify an individual function name, the setting applies only to the function of corresponding precision. So, for example, sinf applies only to the single-precision sine function, sin applies only to the double-precision sine function, sinl applies only to the extended-precision sine function, etc.

    NOTE: Many routines in libraries LIBM (Math Library) and SVML (Short Vector Math Library) are more highly optimized for Intel(R) microprocessors than for non-Intel microprocessors.

    NOTE: This option only applies to host compilation. When offloading is enabled, it does not impact device-specific compilation.

    Product and Performance Information

    = = = = = = = = = =

    Performance varies by use, configuration and other factors. Learn more at
        www.Intel.com/PerformanceIndex.

    Notice revision #20201201

    = = = = = = = = = =

    Alternate Options:

    None

-fimf-accuracy-bits=bits[:funclist] (L*X only)

    Defines the relative error for math
        library function results, including division and square root.

    Arguments:

    bits
        Is a positive, floating-point number indicating the number of correct bits the compiler should use.

        The format for the number is [digits] [.digits] [ { e | E }[sign]digits].

    funclist
        Is an optional list of one or more math library functions to which the attribute should be applied. If you specify more than one function, they must be separated with commas.

        Precision-specific variants like sin and sinf are considered different functions, so you would need to use -fimf-accuracy-bits=23:sin,sinf (or /Qimf-accuracy-bits:23:sin,sinf) to specify the relative error for both the single-precision and double-precision sine functions.

        You also can specify the symbol /f to denote single-precision divides, symbol / to denote double-precision divides, symbol /l to denote extended-precision divides, and symbol /q to denote quad-precision divides. For example you can specify -fimf-accuracy-bits=10.0:/f or /Qimf-accuracy-bits:10.0:/f.

    Default:

    -fimf-precision=medium or
        /Qimf-precision:medium The compiler uses medium precision when calling math library functions. Note that other options can affect precision; see below for details.

    Description:

    This option defines the relative error, measured by the number of correct bits, for math library function results.

    The following formula is used to convert bits into ulps: ulps = 2p-1-bits, where p is the number of the target format mantissa bits (24, 53, and 64 for single, double, and long double, respectively).

    This option can affect runtime performance and the accuracy of results.

    If you need to define the accuracy for a math function of a certain precision, specify the function name of the precision that you need. For example, if you want double precision, you can specify :sin; if you want single precision, you can specify :sinf, as in the following:

    Linux

    •   -fimf-accuracy-bits=23:sinf,cosf,logf

    •   -fimf-accuracy-bits=52:sqrt,/,trunc

    •   -fimf-accuracy-bits=10:powf

    Windows

    •   /Qimf-accuracy-bits:23:sinf,cosf,logf

    •   /Qimf-accuracy-bits:52:sqrt,/,trunc

    •   /Qimf-accuracy-bits:10:powf

    If you do not specify any function names, then the setting applies to all functions (and to all precisions). However, as soon as you specify an individual function name, the setting applies only to the function of corresponding precision. So, for example, sinf applies only to the single-precision sine function, sin applies only to the double-precision sine function, sinl applies only to the extended-precision sine function, etc.

    There are three options you can use to express the maximum relative error. They are as follows:

    Linux

    •   -fimf-precision

    •   -fimf-max-error

    •   -fimf-accuracy-bits

    Windows

    •   /Qimf-precision

    •   /Qimf-max-error

    •   /Qimf-accuracy-bits

    If more than one of these options are specified, the default value for the maximum relative error is determined by the last one specified on the command line.

    If none of the above options are specified, the default values for the maximum relative error are determined by the setting of the following options:

    •   -fp-model (Linux) or /fp (Windows)

    NOTE: Many routines in libraries LIBM (Math Library) and SVML (Short Vector Math Library) are more highly optimized for Intel(R) microprocessors than for non-Intel microprocessors.

    NOTE: This option only applies to host compilation. When offloading is enabled, it does not impact device-specific compilation.

    Product and Performance Information

    = = = = = = = = = =

    Performance varies by use, configuration and other factors. Learn more at
        www.Intel.com/PerformanceIndex.

    Notice revision #20201201

    = = = = = = = = = =

    Alternate Options:

    None

-fimf-arch-consistency=value[:funclist] (L*X only)

    Ensures that the math library functions
        produce consistent results across different microarchitectural implementations of the same architecture.

    Arguments:

    value
        Is one of the logical values "true" or "false".

    funclist
        Is an optional list of one or more math library functions to which the attribute should be applied. If you specify more than one function, they must be separated with commas.

        Precision-specific variants like sin and sinf are considered different functions, so you would need to use -fimf-arch-consistency=true:sin,sinf (or /Qimf-arch-consistency:true:sin,sinf) to specify consistent results for both the single-precision and double-precision sine functions.

        You also can specify the symbol /f to denote single-precision divides, symbol / to denote double-precision divides, symbol /l to denote extended-precision divides, and symbol /q to denote quad-precision divides. For example you can specify -fimf-arch-consistency=true:/ or /Qimf-arch-consistency:true:/.

    Default:

    false
        Implementations of some math library functions may produce slightly different results on implementations of the same architecture.

    Description:

    This option ensures that the math library functions produce consistent results across different microarchitectural implementations of the same architecture (for example, across different microarchitectural implementations of Intel(R) 64 architecture). Consistency is only guaranteed for a single binary. Consistency is not guaranteed across different architectures.

    If you need to define the accuracy for a math function of a certain precision, specify the function name of the precision that you need. For example:

    Linux

    If you want double precision, you can specify :sin; if you want single precision, you can specify :sinf, as in -fimf-arch-consistency=true:sin or -fimf-arch-consistency=false:sqrtf.

    Windows

    If you want double precision, you can specify :sin; if you want single precision, you can specify :sinf, as in /Qimf-arch-consistency:true:sin or /Qimf-arch-consistency:false:sqrtf.

    If you do not specify any function names, then the setting applies to all functions (and to all precisions). However, as soon as you specify an individual function name, the setting applies only to the function of corresponding precision. So, for example, sinf applies only to the single-precision sine function, sin applies only to the double-precision sine function, sinl applies only to the extended-precision sine function, etc.

    The -fimf-arch-consistency (Linux*) and /Qimf-arch-consistency (Windows*) option may decrease runtime performance, but the option will provide bit-wise consistent results on all Intel(R) processors and compatible, non-Intel processors, regardless of micro-architecture. This option may not provide bit-wise consistent results between different architectures.

    NOTE: Many routines in libraries LIBM (Math Library) and SVML (Short Vector Math Library) are more highly optimized for Intel(R) microprocessors than for non-Intel microprocessors.

    NOTE: This option only applies to host compilation. When offloading is enabled, it does not impact device-specific compilation.

    Product and Performance Information

    = = = = = = = = = =

    Performance varies by use, configuration and other factors. Learn more at
        www.Intel.com/PerformanceIndex.

    Notice revision #20201201

    = = = = = = = = = =

    Alternate Options:

    None

-fimf-domain-exclusion=classlist[:funclist] (L*X only)

    Indicates the input arguments domain on
        which math functions must provide correct results.

    Arguments:

    classlist
        Is one of the following:

        •   One or more of the following floating-point value classes you can exclude from the function domain without affecting the correctness of your program. The supported class names are:
            extremes This class is for values which do not lie within the usual domain of arguments for a given function. nans This means "x=Nan". infinities This means "x=infinities". denormals This means "x=denormal". zeros This means "x=0".
        Each classlist element corresponds to a power of two. The exclusion attribute is the logical or of the associated powers of two (that is, a bitmask). The following shows the current mapping from classlist mnemonics to numerical values:

        extremes
            1

        nans
            2

        infinities
            4

        denormals
            8

        zeros
            16

        none
            0

        all 31

        common
            15

        other combinations
            bitwise OR of the used values You must specify the integer value that corresponds to the class that you want to exclude. Note that on excluded values, unexpected results may occur.

        •   One of the following short-hand tokens:
            none This means that none of the supported classes are excluded from the domain. To indicate this token, specify 0, as in -fimf-domain-exclusion=0 (or /Qimf-domain-exclusion:0). all This means that all of the supported classes are excluded from the domain. To indicate this token, specify 31, as in -fimf-domain-exclusion=31 (or /Qimf-domain-exclusion:31). common This is the same as specifying extremes,nans,infinities,denormals. To indicate this token, specify 15 (1 + 2+ 4 + 8), as in -fimf-domain-exclusion=15 (or /Qimf-domain-exclusion:15)

    funclist
        Is an optional list of one or more math library functions to which the attribute should be applied. If you specify more than one function, they must be separated with commas.

        Precision-specific variants like sin and sinf are considered different functions, so you would need to use -fimf-domain-exclusion=4:sin,sinf (or /Qimf-domain-exclusion:4:sin,sinf) to specify infinities for both the single-precision and double-precision sine functions.

        You also can specify the symbol /f to denote single-precision divides, symbol / to denote double-precision divides, symbol /l to denote extended-precision divides, and symbol /q to denote quad-precision divides. For example, you can specify:

        -fimf-domain-exclusion=4 or /Qimf-domain-exclusion:4

        -fimf-domain-exclusion=5:/,powf or /Qimf-domain-exclusion:5:/,powf

        -fimf-domain-exclusion=23:log,logf,/,sin,cosf or /Qimf-domain-exclusion:23:log,logf,/,sin,cosf

        If you don't specify argument funclist, the domain restrictions apply to all math library functions.

    Default:

    Zero ("0")
        The compiler uses default heuristics when calling math library functions.

    Description:

    This option indicates the input arguments domain on which math functions must provide correct results. It specifies that your program will function correctly if the functions specified in funclist do not produce standard conforming results on the number classes.

    This option can affect runtime performance and the accuracy of results. As more classes are excluded, faster code sequences can be used.

    If you need to define the accuracy for a math function of a certain precision, specify the function name of the precision that you need. For example, if you want double precision, you can specify :sin; if you want single precision, you can specify :sinf, as in -fimf-domain-exclusion=denormals:sin or /Qimf-domain-exclusion:denormals:sin, or -fimf-domain-exclusion=extremes:sqrtf or /Qimf-domain-exclusion:extremes:sqrtf.

    If you do not specify any function names, then the setting applies to all functions (and to all precisions). However, as soon as you specify an individual function name, the setting applies only to the function of corresponding precision. So, for example, sinf applies only to the single-precision sine function, sin applies only to the double-precision sine function, sinl applies only to the extended-precision sine function, etc.

    NOTE: Many routines in libraries LIBM (Math Library) and SVML (Short Vector Math Library) are more highly optimized for Intel(R) microprocessors than for non-Intel microprocessors.

    NOTE: This option only applies to host compilation. When offloading is enabled, it does not impact device-specific compilation.

    Product and Performance Information

    = = = = = = = = = =

    Performance varies by use, configuration and other factors. Learn more at
        www.Intel.com/PerformanceIndex.

    Notice revision #20201201

    = = = = = = = = = =

    Alternate Options:

    None

-fimf-max-error=ulps[:funclist] (L*X only)

    Defines the maximum allowable relative
        error for math library function results, including division and square root.

    Arguments:

    ulps
        Is a positive, floating-point number indicating the maximum allowable relative error the compiler should use.

        The format for the number is [digits] [.digits] [ { e | E }[sign]digits].

    funclist
        Is an optional list of one or more math library functions to which the attribute should be applied. If you specify more than one function, they must be separated with commas.

        Precision-specific variants like sin and sinf are considered different functions, so you would need to use -fimf-max-error=4.0:sin,sinf (or /Qimf-max-error=4.0:sin,sinf) to specify the maximum allowable relative error for both the single-precision and double-precision sine functions.

        You also can specify the symbol /f to denote single-precision divides, symbol / to denote double-precision divides, symbol /l to denote extended-precision divides, and symbol /q to denote quad-precision divides. For example you can specify -fimf-max-error=4.0:/ or /Qimf-max-error:4.0:/.

    Default:

    -fimf-precision=medium or
        /Qimf-precision:medium The compiler uses medium precision when calling math library functions. Note that other options can affect precision; see below for details.

    Description:

    This option defines the maximum allowable relative error, measured in ulps, for math library function results.

    This option can affect runtime performance and the accuracy of results.

    If you need to define the accuracy for a math function of a certain precision, specify the function name of the precision that you need. For example, if you want double precision, you can specify :sin; if you want single precision, you can specify :sinf, as in -fimf-max-error=4.0:sin or /Qimf-max-error:4.0:sin, or -fimf-max-error=4.0:sqrtf or /Qimf-max-error:4.0:sqrtf.

    If you do not specify any function names, then the setting applies to all functions (and to all precisions). However, as soon as you specify an individual function name, the setting applies only to the function of corresponding precision. So, for example, sinf applies only to the single-precision sine function, sin applies only to the double-precision sine function, sinl applies only to the extended-precision sine function, etc.

    There are three options you can use to express the maximum relative error. They are as follows:

    Linux

    •   -fimf-precision

    •   -fimf-max-error

    •   -fimf-accuracy-bits

    Windows

    •   /Qimf-precision

    •   /Qimf-max-error

    •   /Qimf-accuracy-bits

    If more than one of these options are specified, the default value for the maximum relative error is determined by the last one specified on the command line.

    If none of the above options are specified, the default values for the maximum relative error are determined by the setting of the following options:

    •   -fp-model (Linux) or /fp (Windows)

    NOTE: Many routines in libraries LIBM (Math Library) and SVML (Short Vector Math Library) are more highly optimized for Intel(R) microprocessors than for non-Intel microprocessors.

    NOTE: This option only applies to host compilation. When offloading is enabled, it does not impact device-specific compilation.

    Product and Performance Information

    = = = = = = = = = =

    Performance varies by use, configuration and other factors. Learn more at
        www.Intel.com/PerformanceIndex.

    Notice revision #20201201

    = = = = = = = = = =

    Alternate Options:

    None

-fimf-precision[=value[:funclist]] (L*X only)

    Lets you specify a level of accuracy
        (precision) that the compiler should use when determining which math library functions to use.

    Arguments:

    value
        Is one of the following values denoting the desired accuracy:

        high
            This is equivalent to max-error = 1.0.

        medium
            This is equivalent to max-error = 4; this is the default setting if the option is specified and value is omitted.

        low This is equivalent to accuracy-bits = 11 for single-precision functions; accuracy-bits = 26 for double-precision functions.

        Linux

        In the above explanations, max-error means option -fimf-max-error; accuracy-bits means option -fimf-accuracy-bits.

        Windows

        In the above explanations, max-error means option /Qimf-max-error (Windows*); accuracy-bits means option /Qimf-accuracy-bits.

    funclist
        Is an optional list of one or more math library functions to which the attribute should be applied.

        If you specify more than one function, they must be separated with commas.

        Precision-specific variants like sin and sinf are considered different functions, so you would need to use -fimf-precision=high:sin,sinf (or /Qimf-precision:high:sin,sinf) to specify high precision for both the single-precision and double-precision sine functions.

        You also can specify the symbol /f to denote single-precision divides, symbol / to denote double-precision divides, symbol /l to denote extended-precision divides, and symbol /q to denote quad-precision divides. For example you can specify -fimf-precision=low:/ or /Qimf-precision:low:/ and -fimf-precision=low:/f or /Qimf-precision:low:/f.

    Default:

    medium
        The compiler uses medium precision when calling math library functions. Note that other options can affect precision; see below for details.

    Description:

    This option lets you specify a level of accuracy (precision) that the compiler should use when determining which math library functions to use.

    This option can be used to improve runtime performance if reduced accuracy is sufficient for the application, or it can be used to increase the accuracy of math library functions selected by the compiler.

    In general, using a lower precision can improve runtime performance and using a higher precision may reduce runtime performance.

    If you need to define the accuracy for a math function of a certain precision, specify the function name of the precision that you need. For example, if you want double precision, you can specify :sin; if you want single precision, you can specify :sinf, as in -fimf-precision=low:sin or /Qimf-precision:low:sin, or -fimf-precision=high:sqrtf or /Qimf-precision:high:sqrtf.

    If you do not specify any function names, then the setting applies to all functions (and to all precisions). However, as soon as you specify an individual function name, the setting applies only to the function of corresponding precision. So, for example, sinf applies only to the single-precision sine function, sin applies only to the double-precision sine function, sinl applies only to the extended-precision sine function, etc.

    There are three options you can use to express the maximum relative error. They are as follows:

    Linux

    •   -fimf-precision

    •   -fimf-max-error

    •   -fimf-accuracy-bits

    Windows

    •   /Qimf-precision

    •   /Qimf-max-error

    •   /Qimf-accuracy-bits

    If more than one of these options are specified, the default value for the maximum relative error is determined by the last one specified on the command line.

    If none of the above options are specified, the default values for the maximum relative error are determined by the setting of the following options:

    •   -fp-model (Linux) or /fp (Windows)

    NOTE: Many routines in libraries LIBM (Math Library) and SVML (Short Vector Math Library) are more highly optimized for Intel(R) microprocessors than for non-Intel microprocessors.

    NOTE: This option only applies to host compilation. When offloading is enabled, it does not impact device-specific compilation.

    Product and Performance Information

    = = = = = = = = = =

    Performance varies by use, configuration and other factors. Learn more at
        www.Intel.com/PerformanceIndex.

    Notice revision #20201201

    = = = = = = = = = =

    Alternate Options:

    None

-fimf-use-svml=value[:funclist] (L*X only)

    Instructs the compiler to use the Short
        Vector Math Library (SVML) rather than the Intel(R) oneAPI DPC++/C++ Compiler Math Library (LIBM) to implement math library functions.

    Arguments:

    funclist
        Is an optional list of one or more math library functions to which the attribute should be applied. If you specify more than one function, they must be separated with commas.

        Precision-specific variants like sin and sinf are considered different functions, so you would need to use -fimf-use-svmlt=true:sin,sinf (or /Qimf-use-svml:true:sin,sinf) to specify that both the single-precision and double-precision sine functions should use SVML.

    Default:

    false
        Math library functions are implemented using the Intel(R) oneAPI DPC++/C++ Compiler Math Library, though other compiler options may give the compiler the flexibility to implement math library functions with either LIBM or SVML.

    Description:

    This option instructs the compiler to implement math library functions using the Short Vector Math Library (SVML).

    Linux

    When you specify option -fimf-use-svml=true, the specific SVML variant chosen is influenced by other compiler options such as -fimf-precision and -fp-model.

    Windows

    When you specify option /Qimf-use-svml:true, the specific SVML variant chosen is influenced by other compiler options such as /Qimf-precision and /fp.

    This option has no effect on math library functions that are implemented in LIBM but not in SVML.

    In value-safe settings of option -fp-model (Linux) or option /fp (Windows) such as precise, this option causes a slight decrease in the accuracy of math library functions, because even the high accuracy SVML functions are slightly less accurate than the corresponding functions in LIBM. Additionally, the SVML functions might not accurately raise floating-point exceptions, do not maintain errno, and are designed to work correctly only in round-to-nearest-even rounding mode.

    The benefit of using -fimf-use-svml=true or /Qimf-use-svml:true with value-safe settings of -fp-model (Linux) or /fp (Windows) is that it can significantly improve performance by enabling the compiler to efficiently vectorize loops containing calls to math library functions.

    If you need to use SVML for a specific math function of a certain precision, specify the function name of the precision that you need. For example, if you want double precision, you can specify :sin; if you want single precision, you can specify :sqrtf, as in -fimf-use-svml=true:sin or /Qimf-use-svml:true:sin, or -fimf-use-svml =false:sqrtf or /Qimf-use-svml:false:sqrtf.

    If you do not specify any function names, then the setting applies to all functions (and to all precisions). However, as soon as you specify an individual function name, the setting applies only to the function of corresponding precision. So, for example, sinf applies only to the single-precision sine function, sin applies only to the double-precision sine function, sinl applies only to the extended-precision sine function, etc.

    NOTE: Since SVML functions may raise unexpected floating-point exceptions, be cautious about using features that enable trapping on floating-point exceptions.

    NOTE: This option only applies to host compilation. When offloading is enabled, it does not impact device-specific compilation.

    Product and Performance Information

    = = = = = = = = = =

    Performance varies by use, configuration and other factors. Learn more at
        www.Intel.com/PerformanceIndex.

    Notice revision #20201201

    = = = = = = = = = =

    Alternate Options:

    None

-finline (L*X only)

-fno-inline (L*X only)

    Tells the compiler to inline functions
        declared with __inline and perform C++ inlining.

    Arguments:

    None

    Default:

    -fno-inline
        The compiler does not inline functions declared with __inline.

    Description:

    This option tells the compiler to inline functions declared with __inline and perform C++ inlining.

    Alternate Options:

    None

-finline-functions (L*X only)

-fno-inline-functions (L*X only)

    Enables function inlining for single file
        compilation.

    Arguments:

    None

    Default:

    -finline-functions
        Interprocedural optimizations occur. However, if you specify -O0, the default is OFF.

    Description:

    This option enables function inlining for single file compilation.

    It enables the compiler to perform inline function expansion for calls to functions defined within the current source file.

    The compiler applies a heuristic to perform the function expansion.

    Alternate Options:

    None

-fintelfpga (L*X only)

    Lets you perform ahead-of-time (AOT)
        compilation for the Field Programmable Gate Array (FPGA).

    Arguments:

    None

    Default:

    OFF The ahead-of-time (AOT) compilation is not performed.

    Description:

    This option lets you perform ahead-of-time (AOT) compilation for the FPGA.

    It is functionally equivalent to specifying the following, which is compiled with dependency and debug information enabled:

    -fsycl-targets=spir64_fpga

    Alternate Options:

    None

-fiopenmp (L*X only)

    Enables recognition of OpenMP* features,
        such as parallel, simd, and offloading directives. This is an alternate option for compiler option [Q or q]openmp.

    Arguments:

    None

    Default:

    OFF No OpenMP* multi-threaded code is generated by the compiler.

    Description:

    This option enables recognition of OpenMP* features, such as parallel, simd, and offloading directives. This is an alternate option for compiler option [Q or q]openmp.

    The -fiopenmp and /Qiopenmp options enable Intel's implementation of OpenMP* in the compiler back end. The compiler front end produces an intermediate representation that preserves the parallelism exposed by OpenMP* directives. The back end uses the exposed parallelism to do more advanced optimizations, such as SIMD vectorization.

    NOTE: To enable offloading to a specified GPU target, you must also specify option fopenmp-targets (Linux*) or /Qopenmp-targets (Windows).

    Product and Performance Information

    = = = = = = = = = =

    Performance varies by use, configuration and other factors. Learn more at
        www.Intel.com/PerformanceIndex.

    Notice revision #20201201

    = = = = = = = = = =

    Alternate Options:

    Linux: -qopenmp

    Windows: /Qopenmp

-fjump-tables (L*X only)

-fno-jump-tables (L*X only)

    Determines whether jump tables are
        generated for switch statements.

    Arguments:

    None

    Default:

    -fjump-tables
        The compiler may use jump tables for switch statements.

    Description:

    This option determines whether jump tables are generated for switch statements.

    Option -fno-jump-tables prevents the compiler from generating jump tables for switch statements. This action is performed unconditionally and independent of any generated code performance consideration.

    Option -fno-jump-tables also prevents the compiler from creating switch statements internally as a result of optimizations.

    Use -fno-jump-tables with -fpic when compiling objects that will be loaded in a way where the jump table relocation cannot be resolved.

    Alternate Options:

    None

-fkeep-static-consts (L*X only)

-fno-keep-static-consts (L*X only)

    Tells the compiler to preserve allocation
        of variables that are not referenced in the source.

    Arguments:

    None

    Default:

    -fno-keep-static-consts
        If a variable is never referenced in a routine, the variable is discarded unless optimizations are disabled by option -O0 (Linux*)

    Description:

    This option tells the compiler to preserve allocation of variables that are not referenced in the source.

    The negated form can be useful when optimizations are enabled to reduce the memory usage of static data.

    Alternate Options:

    None

-flto[=arg] (L*X only)

-fno-lto (L*X only)

    Enables whole program link time
        optimization (LTO).

    Arguments:

    arg Is the link time optimization to perform. Possible values are:

        full
            Tells the compiler to merge all input into a single module before performing link time optimization (LTO).

            This is the default if you specify -flto with no argument.

        thin
            Tells the compiler to read the information from a summary and then do LTO in parallel. This form of LTO (also called ThinLTO) is scalable and incremental.

    Default:

    -fno-lto
        No link time optimization is performed.

    Description:

    This option enables whole program link time optimization (LTO).

    If you specify option -fno-lto, it disables whole program link time optimization.

    If you specify -flto or -flto=full, compilation time may increase because of the additional optimizations.

    Linux:

    You can specify option -ipo as an alias for -flto. -ipo is equivalent to -flto.

    If you want to specify a non-default linker, you must also specify option fuse-ld. Otherwise, the default linker ld will be used.

    Windows:

    You can specify /Qipo as an alias for -flto.

    /Qipo is the same as -flto during the compile step. During the link step, the compiler automatically adds -fuse-ld=lld so the proper linker (lld) will be picked up to perform the expected optimizations. This automatic inclusion is only performed for /Qipo; it is not performed for -flto on Windows.

    NOTE: This option only applies to host compilation. When offloading is enabled, it does not impact device-specific compilation.

    Alternate Options:

    None

-fma (L*X only)

-no-fma (L*X only)

    Determines whether the compiler
        generates fused multiply-add (FMA) instructions if such instructions exist on the target processor.

    Arguments:

    None

    Default:

    -fma
        If the instructions exist on the target processor, the compiler generates fused multiply-add (FMA) instructions.

        However, if you specify -fp-model strict (Linux*), but do not explicitly specify -fma, the default is -no-fma.

    Description:

    This option determines whether the compiler generates fused multiply-add (FMA) instructions if such instructions exist on the target processor. When the [Q]fma option is specified, the compiler may generate FMA instructions for combining multiply and add operations. When the negative form of the [Q]fma option is specified, the compiler must generate separate multiply and add instructions with intermediate rounding.

    This option has no effect unless setting CORE-AVX2 or higher is specified for option [Q]x,-march (Linux), or /arch (Windows).

-fmath-errno (L*X only)

-fno-math-errno (L*X only)

    Tells the compiler that errno can be
        reliably tested after calls to standard math library functions.

    Arguments:

    None

    Default:

    -fno-math-errno
        The compiler assumes that the program does not test errno after calls to standard math library functions.

    Description:

    This option tells the compiler to assume that the program tests errno after calls to math library functions. This restricts optimization because it causes the compiler to treat most math functions as having side effects.

    Option -fno-math-errno tells the compiler to assume that the program does not test errno after calls to math library functions. This frequently allows the compiler to generate faster code. Floating-point code that relies on IEEE exceptions instead of errno to detect errors can safely use this option to improve performance.

    Alternate Options:

    None

-fno-gnu-keywords (L*X only)

    Tells the compiler to not recognize
        typeof as a keyword.

    Arguments:

    None

    Default:

    OFF Keyword typeof is recognized.

    Description:

    Tells the compiler to not recognize typeof as a keyword.

    Alternate Options:

    None

-fno-operator-names (L*X only)

    Disables support for the operator names
        specified in the standard.

    Arguments:

    None

    Default:

    OFF Operator names specified in the standard are supported.

    Description:

    This option disables support for the operator names specified in the standard.

    Alternate Options:

    None

-fno-rtti (L*X only)

    Disables support for runtime type
        information (RTTI).

    Arguments:

    None

    Default:

    OFF Support for runtime type information (RTTI) is enabled.

    Description:

    This option disables support for runtime type information (RTTI).

    Alternate Options:

    None

-fno-sycl-libspirv (L*X only)

    Disables the check for libspirv (the
        SPIR-V* tools library).

    Arguments:

    None

    Default:

    OFF The check for libspirv is enabled.

    Description:

    This option disables the check for libspirv (the SPIR-V* tools library).

    NOTE: When SYCL offloading is enabled, this option only applies to device-specific compilation.

    Alternate Options:

    None

-foffload-static-lib=file (L*X only)

    Tells the compiler to link with a fat
        (multi-architecture) static library. This is a deprecated option that may be removed in a future release.

    Arguments:

    file
        Is the name of the fat static library to use. It can include the path where the library is located.

    Default:

    OFF No linking occurs to a fat static library.

    Description:

    This option tells the compiler to link with a fat (multi-architecture) static library.

    The filename specified is treated as a "fat" static library of device code - an archive of fat objects. When linking, the compiler will extract the device code from the objects contained in the library and link it with other device objects coming from the individual fat objects passed on the command line.

    NOTE: If you try to pass libraries by using compiler option l, there can be dynamic libraries and partial linking with dynamic libraries, which may lead to a crash.

    Alternate Options:

    None

-fomit-frame-pointer (L*X only)

-fno-omit-frame-pointer (L*X only)

    Determines whether EBP is used as a
        general-purpose register in optimizations.

    Arguments:

    None

    Default:

    -fomit-frame-pointer
        EBP is used as a general-purpose register in optimizations.

        However, the default can change depending on the following:

        Linux

        If option -O0 or -g is specified, the default is -fno-omit-frame-pointer.

    Description:

    These options determine whether EBP is used as a general-purpose register in optimizations. Option -fomit-frame-pointer allows this use. Option -fno-omit-frame-pointer disallows it.

    Some debuggers expect EBP to be used as a stack frame pointer, and cannot produce a stack backtrace unless this is so. The -fno-omit-frame-pointer option directs the compiler to generate code that maintains and uses EBP as a stack frame pointer for all functions so that a debugger can still produce a stack backtrace without doing the following:

    •   For -fno-omit-frame-pointer: turning off optimizations with -O0

    The -fno-omit-frame-pointer option is set when you specify option -O0 or the -g option. The -fomit-frame-pointer option is set when you specify option -O1, -O2, or -O3.

    NOTE: On Linux, there is currently an issue with GCC 3.2 exception handling. Therefore, the compiler ignores this option when GCC 3.2 is installed for C++ and exception handling is turned on (the default).

    Alternate Options:

    Linux: -fp

-fopenmp (L*X only)

    Option -fopenmp is a deprecated option
        that will be removed in a future release.

    Arguments:

    None

    Default:

    OFF No OpenMP* multi-threaded code is generated by the compiler.

    Description:

    Enables recognition of OpenMP* features and tells the parallelizer to generate multi-threaded code based on OpenMP* directives.

    This option is meant for advanced users who prefer to use OpenMP* as it is implemented by the LLVM community. You can get most of that functionality by using this option and option -fopenmp-simd.

    Option -fopenmp is a deprecated option that will be removed in a future release. For most users, we recommend that you instead use option qopenmp, Qopenmp.

    NOTE: Option -fopenmp is not the same as option -fiopenmp. If you want to get full advantage of SIMD vectorization or offloading, you must use option -qopenmp.

    NOTE: This option only applies to host compilation. When offloading is enabled, it does not impact device-specific compilation.

    Alternate Options:

    None

-fopenmp-declare-target-scalar-defaultmap=keyword (L*X only)

    Determines which implicit
        data-mapping/sharing rules are applied for a scalar variable referenced in a target pragma.

    Arguments:

    keyword
        Is the rule to be applied for a scalar variable referenced in a target pragma.TARGET directive.. Possible values are:

        default
            Specifies that the compiler should apply implicit data-mapping/sharing rules according to the OpenMP* specification.

            Thus, if a scalar variable referenced in a target construct appears in a to or link clause in a declare target pragma that does not have a device_type (nohost) clause, and the target construct's clauses do not define explicit data-mapping/sharing rules for this variable, then the compiler should treat it as if it had appeared in a map clause with a map-type of tofrom.

        firstprivate
            Specifies that when a scalar variable referenced in a target construct appears in a to or link clause in a declare target pragma that does not have a device_type (nohost) clause, and the target construct's clauses do not define explicit data-mapping/sharing rules for this variable, then the scalar variable should not be mapped, but instead it has an implicit data-sharing attribute of firstprivate.

    Default:

    -fopenmp-declare-target-scalar-defaultmap=default
        The compiler applies implicit data-mapping/sharing rules according to OpenMP specification.

    Description:

    This option determines which implicit data-mapping/sharing rules are applied for a scalar variable referenced in a target pragma, when that scalar variable appears in a declare target pragma that has a to or link clause, but not clause device_type (nohost).

    It tells the compiler to assume that a scalar declare target variable with implicit data-mapping/sharing referenced in a target construct has the same value before the target construct (in the host environment) and at the beginning the target region (in the device environment). This may enable some optimizations in the host code invoking the target region for execution.

    The option only affects data-mapping/sharing rules for scalar variables referenced in a target construct that do not appear in one of the target clauses map, is_device_ptr, or has_device_addr.

    For more information about implicit data-mapping/sharing rules, see the OpenMP 5.2 specification. For example, see section 5.8.1 in that specification.

    Alternate Options:

    None

-fopenmp-device-lib=library[,library,...] (L*X only)

-fno-openmp-device-lib=library[,library,...] (L*X only)

    Enables or disables certain device
        libraries for an OpenMP* target.

    Arguments:

    library
        Possible values are:

        libm-fp32
            Enables linking to the fp32 device math library.

        libm-fp64
            Enables linking to the fp64 device math library.

        libc
            Enables linking to the C library.

        all Enables linking to libraries libm-fp32, libm-fp-64, and libc.

        To link more than one library, include a comma between the library names. For example, if you want to link both the libm-fp32 device library and the C library, specify: libm-fp32,libc.

        Do not add spaces between library names.

        Note that if you specify "all", it supersedes any additional value you may specify.

    Default:

    OFF Disables linking to device libraries for this target.

    Description:

    This option enables or disables certain device libraries for an OpenMP* target.

    If you specify fno-openmp-device-lib=library, linking to the specified library is disabled for the OpenMP* target.

    NOTE: When OpenMP* offloading is enabled, this option only applies to device-specific compilation.

    Alternate Options:

    None

-fopenmp-target-buffers=keyword (L*X only)

    Enables a way to overcome the problem
        where some OpenMP* offload SPIR-V* devices produce incorrect code when a target object is larger than 4GB.

    Arguments:

    keyword
        Possible values are:

        default
            Tells the compiler to use default heuristics. This may produce incorrect code on some OpenMP* offload SPIR-V* devices when a target object is larger than 4GB.

        4GB Tells the compiler to generate code to prevent the issue described by default. OpenMP* offload programs that access target objects of size larger than 4GB in target code require this option.

            This setting applies to the following:

            •   Target objects declared in OpenMP* target regions or inside OpenMP* declare target functions

            •   Target objects that exist in the OpenMP* device data environment

            •   Objects that are mapped and/or allocated by means of OpenMP* APIs (such as omp_target_alloc)

    Default:

    default
        If you do not specify this option, the compiler may produce incorrect code on some OpenMP* offload SPIR-V* devices when a target object is larger than 4GB.

    Description:

    This option enables a way to overcome the problem where some OpenMP* offload SPIR-V* devices produce incorrect code when a target object is larger than 4GB (4294959104 bytes).

    However, note that when -fopenmp-target-buffers=4GB (or /Qopenmp-target-buffers:4GB) is specified on Intel(R) GPUs, there may be a decrease in performance.

    To use this option, you must also specify option -fopenmp-targets (Linux*) or /Qopenmp-targets (Windows*).

    NOTE: This option may have no effect for some OpenMP* offload SPIR-V* devices, and for OpenMP* offload targets different from SPIR*.

    NOTE: When OpenMP* offloading is enabled, this option only applies to device-specific compilation.

    Alternate Options:

    None

-fopenmp-targets=triple (L*X only)

    Enables offloading to a specified GPU
        target if OpenMP* features have been enabled.

    Arguments:

    triple
        Is a target triple device name. The following triplets are supported.

        spir64
            Tells the compiler to enable offloading to SPIR64-based devices.

        spir64_x86_64
            Tells the compiler to enable offloading to Intel(R) CPUs.

        spir64_gen
            Tells the compiler to enable offloading to Intel(R) Processor Graphics.

        For example, when you specify spir64, the compiler generates an x86 + SPIR64 (64-bit Standard Portable Intermediate Representation) fat binary for Intel(R) GPU devices.

    Default:

    OFF If this option is not specified, no fat binaries are created.

    Description:

    This option enables offloading to a specified GPU target if OpenMP* features have been enabled.

    To use this option, you must enable recognition of OpenMP* features by specifying one of the following options:

    Linux

    •   -qopenmp

    •   -fiopenmp

    •   -fopenmp (deprecated; it is equivalent to -qopenmp)

    Windows

    •   /Qopenmp

    •   /Qiopenmp

    The following shows an example:

    icx (or icpx) -fiopenmp -fopenmp-targets=spir64 matmul_offload.cpp -o matmul

    When you specify -fopenmp-targets or /Qopenmp-targets, C++ exception handling is disabled for target compilations.

    Linux

    For host compilations, if you want to disable C++ exception handling, you must specify option -fno-exceptions.

    NOTE: When OpenMP* offloading is enabled, this option only applies to device-specific compilation.

    Alternate Options:

    None

-foptimize-sibling-calls (L*X only)

-fno-optimize-sibling-calls (L*X only)

    Determines whether the compiler optimizes
        tail recursive calls.

    Arguments:

    None

    Default:

    -foptimize-sibling-calls
        The compiler optimizes tail recursive calls.

    Description:

    This option determines whether the compiler optimizes tail recursive calls. It enables conversion of tail recursion into loops.

    If you do not want to optimize tail recursive calls, specify -fno-optimize-sibling-calls.

    Tail recursion is a special form of recursion that doesn't use stack space. In tail recursion, a recursive call is converted to a GOTO statement that returns to the beginning of the function. In this case, the return value of the recursive call is only used to be returned. It is not used in another expression. The recursive function is converted into a loop, which prevents modification of the stack space used.

    Alternate Options:

    None

-fp-model=keyword (L*X only)

    Controls the semantics of floating-point
        calculations.

    Arguments:

    keyword
        Specifies the semantics to be used. Possible values are:

        precise
            Disables optimizations that are not value-safe on floating-point data.

        fast
            Enables more aggressive optimizations on floating-point data.

        strict
            Enables precise, disables contractions, and enables pragma stdc fenv_access.

    Default:

    -fp-model=fast
        The compiler uses more aggressive optimizations on floating-point calculations.

    Description:

    This option controls the semantics of floating-point calculations.

    The floating-point (FP) environment is a collection of registers that control the behavior of FP machine instructions and indicate the current FP status. The floating-point environment may include rounding-mode controls, exception masks, flush-to-zero controls, exception status flags, and other floating-point related features.

    Option
        Description

    -fp-model=precise or
        /fp:precise Tells the compiler to strictly adhere to value-safe optimizations when implementing floating-point calculations. It disables optimizations that can change the result of floating-point calculations, which is required for strict ANSI conformance.

    These semantics ensure the reproducibility of
        floating-point computations for serial code, including code vectorized or auto-parallelized by the compiler, but they may slow performance. They do not ensure value safety or run-to-run reproducibility of other parallel code.

    Run-to-run reproducibility for
        floating-point reductions in OpenMP* code may be obtained for a fixed number of threads through the KMP_DETERMINISTIC_REDUCTION environment variable. For more information about this environment variable, see topic "Supported Environment Variables".

    The compiler assumes the default floating-point
        environment; you are not allowed to modify it.

    -fp-model=fast or
        /fp:fast Tells the compiler to use more aggressive optimizations when implementing floating-point calculations. These optimizations increase speed, but they may affect the accuracy or reproducibility of floating-point computations.

    -fp-model=strict or
        /fp:strict Tells the compiler to strictly adhere to value-safe optimizations when implementing floating-point calculations and enables floating-point exception semantics. This is the strictest floating-point model.

    The compiler does not assume the default
        floating-point environment; you are allowed to modify it.

    The -fp-model and /fp options determine the setting for the maximum allowable relative error for math library function results (max-error) if none of the following options are specified:

    •   -fimf-accuracy-bits (Linux*) or /Qimf-accuracy-bits (Windows*)

    •   -fimf-max-error (Linux) or /Qimf-max-error (Windows)

    •   -fimf-precision (Linux) or /Qimf-precision (Windows)

    Option -fp-model=fast (and /fp:fast) sets option -fimf-precision=medium (/Qimf-precision:medium) and option -fp-model=precise (and /fp:precise); it implies -fimf-precision=high (and /Qimf-precision:high).

    Product and Performance Information

    = = = = = = = = = =

    Performance varies by use, configuration and other factors. Learn more at
        www.Intel.com/PerformanceIndex.

    Notice revision #20201201

    = = = = = = = = = =

    Alternate Options:

    None

-fp-speculation=mode (L*X only)

    Tells the compiler the mode in which to
        speculate on floating-point operations.

    Arguments:

    mode
        Is the mode for floating-point operations. Possible values are:

        fast
            Tells the compiler to speculate on floating-point operations.

        safe
            Tells the compiler to disable speculation if there is a possibility that the speculation may cause a floating-point exception.

        strict
            Tells the compiler to disable speculation on floating-point operations.

    Default:

    -fp-speculation=fast
        The compiler speculates on floating-point operations. This is also the behavior when optimizations are enabled.

        However, if you specify no optimizations (-O0), the default changes:

        Linux

        In this case, the default is -fp-speculation=safe.

    Description:

    This option tells the compiler the mode in which to speculate on floating-point operations.

    Disabling speculation may prevent the vectorization of some loops containing conditionals.

    Alternate Options:

    None

-fpack-struct (L*X only)

    Specifies that structure members should
        be packed together.

    Arguments:

    None

    Default:

    OFF

    Description:

    Specifies that structure members should be packed together.

    NOTE: Using this option may result in code that is not usable with standard (system) c and C++ libraries.

    Alternate Options:

    Linux: -Zp1

-fpermissive (L*X only)

    Tells the compiler to allow for
        non-conformant code.

    Arguments:

    None

    Default:

    OFF The compiler does not allow for non-conformant code.

    Description:

    Tells the compiler to allow for non-conformant code.

    Alternate Options:

    None

-fpic (L*X only)

-fno-pic (L*X only)

    Determines whether the compiler generates
        position-independent code.

    Arguments:

    None

    Default:

    -fno-pic
        The compiler does not generate position-independent code.

    Description:

    This option determines whether the compiler generates position-independent code.

    Option -fpic specifies full symbol preemption. Global symbol definitions as well as global symbol references get default (that is, preemptable) visibility unless explicitly specified otherwise.

    Option -fpic must be used when building shared objects.

    This option can also be specified as -fPIC.

    Alternate Options:

    None

-fpie (L*X only)

    Tells the compiler to generate
        position-independent code. The generated code can only be linked into executables.

    Arguments:

    None

    Default:

    OFF The compiler does not generate position-independent code for an executable-only object.

    Description:

    This option tells the compiler to generate position-independent code. It is similar to -fpic, but code generated by -fpie can only be linked into an executable.

    Because the object is linked into an executable, this option causes better optimization of some symbol references.

    To ensure that runtime libraries are set up properly for the executable, you should also specify option -pie to the compiler driver on the link command line.

    Option -fpie can also be specified as -fPIE.

    Alternate Options:

    None

-fshort-enums (L*X only)

    Tells the compiler to allocate as many
        bytes as needed for enumerated types.

    Arguments:

    None

    Default:

    OFF The compiler allocates a default number of bytes for enumerated types.

    Description:

    This option tells the compiler to allocate as many bytes as needed for enumerated types.

    Alternate Options:

    None

-fstack-protector[-keyword] (L*X only)

-fno-stack-protector[-keyword] (L*X only)

    Enables or disables stack overflow
        security checks for certain (or all) routines.

    Arguments:

    keyword
        Possible values are:

        strong
            When option -fstack-protector-strong is specified, it enables stack overflow security checks for routines with any type of buffer.

        all When option -fstack-protector-all is specified, it enables stack overflow security checks for every routine.

    If no -keyword is specified, option -fstack-protector enables stack overflow security checks for routines with a string buffer.

    Default:

    -fno-stack-protector,
        -fno-stack-protector-strong No stack overflow security checks are enabled for the relevant routines.

    -fno-stack-protector-all
        No stack overflow security checks are enabled for any routines.

    Description:

    This option enables or disables stack overflow security checks for certain (or all) routines. A stack overflow occurs when a program stores more data in a variable on the execution stack than is allocated to the variable. Writing past the end of a string buffer or using an index for an array that is larger than the array bound could cause a stack overflow and security violations.

    The -fstack-protector options are provided for compatibility with gcc. They use the gcc/glibc implementation when possible. If the gcc/glibc implementation is not available, they use the Intel implementation.

    Alternate Options:

    None

-fstack-security-check (L*X only)

-fno-stack-security-check (L*X only)

    Determines whether the compiler generates
        code that detects some buffer overruns.

    Arguments:

    None

    Default:

    -fno-stack-security-check
        The compiler does not detect buffer overruns.

    Description:

    This option determines whether the compiler generates code that detects some buffer overruns that overwrite the return address. This is a common technique for exploiting code that does not enforce buffer size restrictions.

    This option always uses an Intel implementation.

    For a gcc-compliant version of this feature, see option fstack-protector.

    NOTE: This option only applies to host compilation. When offloading is enabled, it does not impact device-specific compilation.

    Alternate Options:

    Linux: None

    Windows: /GS

-fsycl (L*X only)

    Enables a program to be compiled as a
        SYCL program rather than as plain C++11 program.

    Arguments:

    None

    Default:

    SYCL: ON
        A C++ program is compiled as a SYCL program.

    C++: OFF
        A C++ program is compiled as a C++11 program.

    Description:

    This option enables a program to be compiled as a SYCL program rather than as plain C++11 program.

    Alternate Options:

    None

-fsycl-add-targets=T1:file1,...,Tn:filen (L*X only)

    Lets you add arbitrary device binary
        images to the fat SYCL* binary when linking. This is a deprecated option that may be removed in a future release.

    Arguments:

    T   Is a target triple for the device binary image.

    file
        Is the location of the device binary image.

    You can specify one or more pair of T:file.

    Default:

    OFF Arbitrary device images are not added to any fat SYCL* binary being linked.

    Description:

    This option lets you add arbitrary device binary images to the fat SYCL* binary when linking.

    NOTE: When using this option, you must also specify option -fsycl.

    NOTE: When SYCL offloading is enabled, this option only applies to device-specific compilation.

    Alternate Options:

    None

-fsycl-dead-args-optimization (L*X only)

-fno-sycl-dead-args-optimization (L*X only)

    Enables elimination of SYCL dead kernel
        arguments.

    Arguments:

    None

    Default:

    OFF SYCL dead kernel arguments are not eliminated. This default may change in the future.

    Description:

    This option enables elimination of SYCL dead kernel arguments. This optimization can improve performance.

    NOTE: When using this option, you must also specify option -fsycl.

    If you specify -fno-sycl-dead-args-optimization, this optimization is disabled.

    NOTE: When SYCL offloading is enabled, this option only applies to device-specific compilation.

    Alternate Options:

    None

-fsycl-device-code-split[=value] (L*X only)

    Specifies a SYCL* device code module
        assembly.

    Arguments:

    value
        Can be only one of the following:

        per_kernel
            Creates a separate device code module for each SYCL* kernel. Each device code module will contain a kernel and all its dependencies, such as called functions and used variables.

        per_source
            Creates a separate device code module for each source (translation unit).

            Each device code module will contain a collection of kernels grouped on per-source basis and all their dependencies, such as all used variables and called functions, including the SYCL_EXTERNAL macro-marked functions from other translation units.

        off Creates a single module for all kernels.

        auto
            The compiler will use a heuristic to select the best way of splitting device code. This is the same as specifying fsycl-device-code-split with no value.

    Default:

    auto
        This is the default whether you do not specify the compiler option or you do specify the compiler option, but omit a value. The compiler will use a heuristic to select the best way of splitting device code.

    Description:

    This option specifies a SYCL* device code module assembly.

    CAUTION: If option -fno-sycl-rdc is also specified, option -fsycl-device-code-split=off is equivalent to -fsycl-device-code-split=per_source.

    NOTE: When using this option, you must also specify option -fsycl.

    NOTE: When SYCL offloading is enabled, this option only applies to device-specific compilation.

    Alternate Options:

    None

-fsycl-device-lib=library[,library,...] (L*X only)

-fno-sycl-device-lib=library[,library,...] (L*X only)

    Enables or disables certain device
        libraries for a SYCL* target.

    Arguments:

    library
        Possible values are:

        libm-fp32
            Enables linking to the fp32 device math library.

        libm-fp64
            Enables linking to the fp64 device math library.

        libc
            Enables linking to the C library.

        all Enables linking to libraries libm-fp32, libm-fp-64, and libc.

        To link more than one library, include a comma between the library names. For example, if you want to link both the libm-fp32 device library and the C library, specify: libm-fp32,libc.

        Do not add spaces between library names.

        Note that if you specify "all", it supersedes any additional value you may specify.

    Default:

    OFF Disables linking to device libraries for this target.

    Description:

    This option enables or disables certain device libraries for a SYCL* target.

    NOTE: When using this option, you must also specify option -fsycl.

    If you specify fno-sycl-device-lib=library, linking to the specified library is disabled for the SYCL* target.

    NOTE: When SYCL offloading is enabled, this option only applies to device-specific compilation.

    Alternate Options:

    None

-fsycl-device-only (L*X only)

    Tells the compiler to generate a
        device-only binary.

    Arguments:

    None

    Default:

    OFF No device-only binary is generated.

    Description:

    This option tells the compiler to generate a device-only binary.

    NOTE: When SYCL offloading is enabled, this option only applies to device-specific compilation.

    Alternate Options:

    None

-fsycl-early-optimizations (L*X only)

-fno-sycl-early-optimizations (L*X only)

    Enables LLVM-related optimizations before
        SPIR-V* generation.

    Arguments:

    None

    Default:

    ON  LLVM-related optimizations are enabled before SPIR-V* generation.

    Description:

    This option enables LLVM-related optimizations before SPIR-V* generation. These optimizations can improve performance.

    NOTE: When using this option, you must also specify option -fsycl.

    If you specify -fno-sycl-early-optimizations, these optimizations are disabled.

    NOTE: When SYCL offloading is enabled, this option only applies to device-specific compilation.

    Alternate Options:

    None

-fsycl-enable-function-pointers (L*X only)

    Enables function pointers and support for
        virtual functions for SYCL kernels and device functions. This is an experimental feature.

    Arguments:

    None

    Default:

    OFF Function pointers are not enabled and virtual functions for SYCL kernels and device functions are not supported.

    Description:

    This option enables function pointers and support for virtual functions for SYCL kernels and device functions. This is an experimental feature.

    This enhanced support is limited to CPU-device only and cannot currently be used for GPU devices.

    NOTE: When using this option, you must also specify option -fsycl.

    NOTE: When SYCL offloading is enabled, this option only applies to device-specific compilation.

    Alternate Options:

    None

-fsycl-esimd-force-stateless-mem (L*X only)

-fno-sycl-esimd-force-stateless-mem (L*X only)

    Determines whether the compiler enforces
        stateless memory accesses within ESIMD kernels on the target device. This is an experimental feature.

    Arguments:

    None

    Default:

    OFF Memory accesses that are stateful are not converted to stateless.

    Description:

    This option determines whether the compiler enforces stateless memory accesses within ESIMD kernels on the target device. This is an experimental feature.

    Option -fsycl-esimd-force-stateless-mem uses SYCL* accessors to convert stateful memory to stateless memory. SIMD intrinsics that cannot be automatically converted are disabled and reported during the compilation phase.

    In cases where a target does not support stateful accesses, option -fsycl-esimd-force-stateless-mem may be helpful to avoid issues caused by the 4Gb-per-surface limitation in programs written with SYCL accessors.

    NOTE: When using this option, you must also specify option -fsycl.

    If you specify -fno-sycl-esimd-force-stateless-mem, the compiler does not enforce stateless memory accesses.

    NOTE: When SYCL offloading is enabled, this option only applies to device-specific compilation.

    Alternate Options:

    None

-fsycl-explicit-simd (L*X only)

-fno-sycl-explicit-simd (L*X only)

    Enables or disables the experimental
        "Explicit SIMD" SYCL* extension. This is a deprecated option that may be removed in a future release.

    Arguments:

    None

    Default:

    -fno-sycl-explicit-simd
        The explicit SIMD SYCL* extension is disabled.

    Description:

    This option enables or disables the experimental "Explicit SIMD" SYCL* extension.

    If you specify option -fsycl-explicit-simd, it enables the experimental "Explicit SIMD" SYCL* extension for lower-level Intel GPU programming. It allows you to write explicitly vectorized device code. Note that APIs for this feature may change in the future.

    NOTE: When using this option, you must also specify option -fsycl.

    NOTE: When SYCL offloading is enabled, this option only applies to device-specific compilation.

    Alternate Options:

    None

-fsycl-force-target=triple (L*X only)

    Forces the compiler to use the specified
        target triple device when extracting device code from any given objects on the command line.

    Arguments:

    triple
        Is a target triple device name. It tells the compiler which target should be unbundled or extracted from fat objects or archives that have already been generated.

        The following triplets are supported:

        spir64
            Tells the compiler that the target is a SPIR64-based device.

        spir64_x86_64
            Tells the compiler that the target is Intel(R) CPU.

        spir64_fpga
            Tells the compiler that the target is Intel(R) FPGA.

        spir64_gen
            Tells the compiler that the target is Intel(R) Processor Graphics.

    Default:

    OFF If this option is not specified, the compiler will unbundle or extract based on the setting of option -fsycl-targets.

    Description:

    This option forces the compiler to use the specified target triple device when extracting device code from any given objects on the command line.

    You can have both spir64 and spir64_gen in your objects. When -fsycl-force-target is specified, the compiler will use the target specified in that option. It will not use the value specified in -fsycl-targets, even if it exists.

    NOTE: When using this option, you must also specify option -fsycl.

    NOTE: When SYCL offloading is enabled, this option only applies to device-specific compilation.

    Alternate Options:

    None

-fsycl-help[=arg] (L*X only)

    Causes help information to be emitted
        from the device compiler backend.

    Arguments:

    arg Can be one of "x86_64", "fpga", "gen", or "all". Option -fsycl-help=all outputs help for "x86_64", "fpga", and "gen".

        Specifying "all" is the same as specifying fsycl-help with no arg.

    Default:

    OFF No help information is emitted from the device compiler backend.

    Description:

    This option causes help information to be emitted from the device compiler backend.

    NOTE: When SYCL offloading is enabled, this option only applies to device-specific compilation.

    Alternate Options:

    None

-fsycl-host-compiler=arg (L*X only)

    Tells the compiler to use the specified
        compiler for the host compilation of the overall offloading compilation that is performed.

    Arguments:

    arg Is the compiler that will be the host for compilation.

        It can be the name of a compiler or the specific path to the compiler.

    Default:

    Linux: OFF
        The host compilation will be performed by the Intel(R) DPC++ Compiler.

    Windows:
        /Zc:__cplusplus The host compilation will be performed by the Microsoft* __cplusplus preprocessor macro, which depends on the setting of option /std (or /Qstd). For more information about macro /Zc:__cplusplus, see the Microsoft documentation.

        To override this default, specify option /fsycl-host-compiler-options=/Zc:cplusplus-.

    Description:

    This option tells the compiler to use the specified compiler for the host compilation of the overall offloading compilation that is performed.

    NOTE: When using this option, you must also specify option -fsycl.

    Alternate Options:

    None

-fsycl-host-compiler-options="opts" (L*X only)

    Passes options to the compiler specified
        by option fsycl-host-compiler.

    Arguments:

    opts
        Is a string of compatible compiler options to be passed. The string must appear within quotes.

        If there is more than one compiler option, a space must appear between each option name.

    Default:

    OFF No options are passed to the compiler specified by -fsycl-host-compiler.

    Description:

    This option tells the compiler to pass options to the compiler specified by option fsycl-host-compiler. The options must be compatible with the compiler specified by fsycl-host-compiler.

    NOTE: Specifying any kind of phase limiting options (such as -c, -E, or -S) may interfere with the expected output set during the host compilation. This can cause undefined behavior.

    NOTE: When using this option, you must also specify option -fsycl.

    Alternate Options:

    None

-fsycl-id-queries-fit-in-int (L*X only)

-fno-sycl-id-queries-fit-in-int (L*X only)

    Tells the compiler to assume that SYCL ID
        queries fit within MAX_INT.

    Arguments:

    None

    Default:

    ON  The compiler assumes that SYCL ID queries fit within MAX_INT.

    Description:

    This option tells the compiler to assume that SYCL ID queries fit within MAX_INT. It assumes that the following values fit within MAX_INT:

    •   id class get() member function and operator[]

    •   item class get_id() member function and operator[]

    •   nd_item class get_global_id()/get_global_linear_id() member functions

    For more information about these values, see the Khronos* Group SYCL* 1.2.1 Specification.

    If you need to use a larger number of work items, use the OFF setting for this option, which is -fno-sycl-id-queries-fit-in-int.

    CAUTION: You should carefully evaluate whether you should use the OFF setting when you have a larger number of work items. Truncating to data type int is often incorrect in such circumstances. If the OFF setting is used when the values fit within MAX_INT, it can lead to unexpected performance issues.

    NOTE: When using this option, you must also specify option -fsycl.

    NOTE: When SYCL offloading is enabled, this option only applies to device-specific compilation.

    Alternate Options:

    None

-fsycl-instrument-device-code-split (L*X only)

-fno-sycl-instrument-device-code-split (L*X only)

    Enables or disables linking of the
        Instrumentation and Tracing Technology (ITT) device libraries for VTune(TM).

    Arguments:

    None

    Default:

    ON  The device libraries needed for Instrumentation and Tracing Technology (ITT) are enabled.

    Description:

    This option enables or disables linking of the Instrumentation and Tracing Technology (ITT) device libraries for VTune(TM). This provides annotations to intercept various events inside kernels generated by Just in Time (JIT) compilation.

    NOTE: When using this option, you must also specify option -fsycl.

    If you specify -fno-sycl-instrument-device-code-split, no linking occurs to the Instrumentation and Tracing Technology (ITT) device libraries.

    NOTE: When SYCL offloading is enabled, this option only applies to device-specific compilation.

    Alternate Options:

    None

-fsycl-link[=value] (L*X only)

    Tells the compiler to perform a partial
        link of device binaries to be used with Field Programmable Gate Array (FPGA).

    Arguments:

    value
        Can be one of the following:

        early
            Tells the compiler to generate an HTML report when the partial link is created. This capability lets you check the program if need be.

            You can resume from this point and generate an FPGA image by specifying option -fintelfpga with the generated binary.

        image
            Tells the compiler to generate an FPGA bitstream. It will then be ready to be linked and used on an FPGA board.

        image takes much longer to generate than does early.

    Default:

    OFF No partial link of device binaries is performed.

    Description:

    This option tells the compiler to perform a partial link of device binaries to be used with FPGA.

    This partial link is then wrapped by the offload wrapper, allowing the device binaries to be linked by the host compiler or linker.

    If you do not specify a value, the following occurs:

    •   When used with just -fsycl (-fsycl -fsycl-link), the driver will generate a host linkable device object.

    •   When also used with -fintelfpga (-fsycl -fintelfpga -fsycl-link), the behavior is the same as specifying -fsycl-link=early.

    NOTE: When using this option, you must also specify option -fsycl.

    NOTE: When SYCL offloading is enabled, this option only applies to device-specific compilation.

    Alternate Options:

    None

-fsycl-link-huge-device-code (L*X only)

-fno-sycl-link-huge-device-code (L*X only)

    Tells the compiler to place device code
        later in the linked binary. This is to prevent 32-bit PC-relative relocations between surrounding Executable and Linkable Format (ELF) sections when the device code is larger than 2GB.

    Arguments:

    None

    Default:

    fno-sycl-link-huge-device-code
        No change is made to the linked binary.

    Description:

    This option tells the compiler to place device code later in the linked binary. This is to prevent 32-bit PC-relative relocations between surrounding Executable and Linkable Format (ELF) sections when the device code is larger than 2GB.

    This option impacts the host link for a full offload compilation. It does not impact device compilation directly, but it is only useful when offloading is performed.

    NOTE: When using this option, you must also specify option -fsycl.

    NOTE: This option only takes effect if a link action needs to be executed. For example, it will not have any effect if certain other options are specified, such as -c or -E.

    Alternate Options:

    None

-fsycl-link-targets=T1,...,Tn (L*X only)

    Tells the compiler to link only device
        code. This is a deprecated option that may be removed in a future release.

    Arguments:

    T   Is a target triple for the device code. You can specify more than one T.

    Default:

    OFF No link is performed.

    Description:

    This option tells the compiler to link only device code. It is used in a link step.

    It tells the compiler to link device code for the given target triples, and output multiple linked device code images. It does not produce fat binary.

    NOTE: You should be familiar with ahead-of-time (AOT) compilation when using this option.

    NOTE: When using this option, you must also specify option -fsycl.

    NOTE: When SYCL offloading is enabled, this option only applies to device-specific compilation.

    Alternate Options:

    None

-fsycl-max-parallel-link-jobs=n (L*X only)

    Tells the compiler that it can
        simultaneously spawn up to the specified number of processes to perform actions required to link SYCL applications. This is an experimental feature.

    Arguments:

    n   Is the number of processes to spawn to.

    Default:

    -fsycl-max-parallel-link-jobs=1
        One process is simultaneously spawned to perform actions necessary to link SYCL applications.

    Description:

    This option tells the compiler that it can simultaneously spawn up to the specified number of processes to perform actions required to link SYCL applications. This is an experimental feature.

    Note the following limitations when using this option:

    •   This option has no effect if compiler options such as c or E are specified.

    •   The option does not take effect when device code split is turned off by option -fsycl-device-code-split=off.

    •   The number of processes spawned by -fsycl-max-parallel-link-jobs will not exceed the number of device code modules stemming from the application. For example, if the application contains m kernels, per_kernel device code split is requested, and n > m processes are requested by -fsycl-max-parallel-link-jobs, m processes will be the spawned maximum.

    •   It is not guaranteed that n processes will always be active. For example, the current implementation does not enforce that the additional process will be instantly re-assigned to the next device code module after it has finished operating on the current one.

    •   It is not guaranteed that spawning device link processes can be safely combined with the build system-level parallelization. Whenever specifying a large number of processes to be spawned for device code linkage, you need to beware of increased RAM usage, oversubscription risks, etc., which may cause performance and possibly compilation issues.

    NOTE: When using this option, you must also specify option -fsycl.

    NOTE: When SYCL offloading is enabled, this option only applies to device-specific compilation.

    Alternate Options:

    None

-fsycl-optimize-non-user-code (L*X only)

    Tells the compiler to optimize SYCL
        framework utility functions and to leave the kernel code unoptimized for further debugging.

    Arguments:

    None

    Default:

    OFF SYCL framework functions and methods are not optimized.

    Description:

    This option tells the compiler to optimize SYCL framework utility functions and to leave the kernel code unoptimized for further debugging.

    To use this option, you must also specify option -O0 (Linux) or /Od (Windows). Do not specify any other optimization setting or you will get a compilation error.

    NOTE: When using this option, you must also specify option -fsycl.

    NOTE: This option only applies to host compilation. When offloading is enabled, it does not impact device-specific compilation.

    Alternate Options:

    None

-fsycl-rdc (L*X only)

-fno-sycl-rdc (L*X only)

    Determines whether the compiler generates
        device code in one module (normal behavior) or it generates separate device code per source.

    Arguments:

    None

    Default:

    -fsycl-rdc
        The compiler links all device code together into one module.

    Description:

    This option determines whether the compiler generates device code in one module (normal behavior) or it generates separate device code per source.

    If you specify -fno-sycl-rdc, a separate SYCL* device code module is created for each source. The compiler will not link all device code together, but instead will treat device code in each compilation unit as independent. Note that this option does not support SYCL_EXTERNAL functions; if they are specified, an error will be displayed.

    Specifying -fno-sycl-rdc may improve runtime and memory usage.

    CAUTION: Option -fno-sycl-rdc can affect option -fsycl-device-code-split. If you specify both options, -fsycl-device-code-split=off is equivalent to -fsycl-device-code-split=per_source.

    NOTE: When using this option, you must also specify option -fsycl.

    NOTE: When SYCL offloading is enabled, this option only applies to device-specific compilation.

    Alternate Options:

    None

-fsycl-targets=T1,...,Tn (L*X only)

    Tells the compiler to generate code for
        specified device targets.

    Arguments:

    T   Is a target triple device name. If you specify more than one T, they must be separated by commas. The following triplets are supported:

        spir64
            Tells the compiler to use default heuristics for SPIR64-based devices. This is the default. You can also specify this value as spir64-unknown-unknown.

        spir64_x86_64
            Tells the compiler to generate code for Intel(R) CPUs. You can also specify this value as spir64_x86_64-unknown-unknown.

        x86_64
            Tells the compiler to generate code ahead of time for x86_64 CPUs; it provides better debuggability. This triplet can also be specified as x86_64-unknown-unknown.

        spir64_fpga
            Tells the compiler to generate code for Intel(R) FPGA. You can also specify this value as spir64_fpga-unknown-unknown.

        spir64_gen
            Tells the compiler to generate code for Intel(R) Processor Graphics. You can also specify this value as spir64_gen-unknown-unknown.

    Default:

    spir64
        The compiler will use default heuristics for SPIR64-based devices.

    Description:

    This option tells the compiler to generate code for specified device targets.

    NOTE: The long syntax values that include -sycldevice, such as spir64-unknown-unknown-sycldevice, are still supported, but they are deprecated.

    NOTE: When using this option, you must also specify option -fsycl.

    NOTE: When SYCL offloading is enabled, this option only applies to device-specific compilation.

    Alternate Options:

    None

-fsycl-unnamed-lambda (L*X only)

-fno-sycl-unnamed-lambda (L*X only)

    Enables unnamed SYCL* lambda kernels.

    Arguments:

    None

    Default:

    ON  Unnamed SYCL lambda kernels are enabled.

    Description:

    This option enables unnamed SYCL kernels that are defined as lambdas.

    NOTE: When using this option, you must also specify option -fsycl.

    If you specify -fno-sycl-unnamed-lambda, unnamed SYCL lambda kernels are disabled.

    NOTE: When SYCL offloading is enabled, this option only applies to device-specific compilation.

    Alternate Options:

    None

-fsycl-use-bitcode (L*X only)

    Tells the compiler to produce device code
        in LLVM Intermediate Representation (IR) bitcode format into fat objects.

    Arguments:

    None

    Default:

    ON  LLVM IR bitcode format is emitted.

    Description:

    This option tells the compiler to produce device code in LLVM Intermediate Representation (IR) bitcode format into fat objects.

    NOTE: When using this option, you must also specify option -fsycl.

    NOTE: When SYCL offloading is enabled, this option only applies to device-specific compilation.

    Alternate Options:

    None

-fsyntax-only (L*X only)

    Tells the compiler to check only for
        correct syntax.

    Arguments:

    None

    Default:

    OFF Normal compilation is performed.

    Description:

    This option tells the compiler to check only for correct syntax. No object file is produced.

    Alternate Options:

    None

-ftarget-compile-fast (L*X only)

    Tells the compiler to perform less
        aggressive optimizations to reduce compilation time at the expense of generating less optimal target code. This is an experimental feature.

    Arguments:

    None

    Default:

    OFF Less aggressive optimizations to reduce compilation time are not performed.

    Description:

    This option tells the compiler to perform less aggressive optimizations to reduce compilation time at the expense of generating less optimal target code. This is an experimental feature.

    It may be useful to specify this option in these cases:

    •   When you are in a development period and want a fast turnaround time while testing

    •   When you are specifying options O2 or O3 for a product with Just-in-Time (JIT) compilation, and both compile-time and execution performance are important

    This option is not recommended when you are specifying options O2 or O3 for a product with Ahead-of-Time (AOT) compilation, where long but one-time compilation may be tolerable in order to achieve the best performance.

    NOTE: This compiler option is not recommended if you plan to ship object files as part of a final product.

    NOTE: This option only applies to host compilation. When offloading is enabled, it does not impact device-specific compilation.

    Alternate Options:

    None

-funsigned-char (L*X only)

    Sets the default character type to
        unsigned.

    Arguments:

    None

    Default:

    OFF The default character type is signed.

    Description:

    This option sets the default character type to unsigned. This option has no effect on character values that are explicitly declared signed. This option sets _CHAR_UNSIGNED = 1.

    Alternate Options:

    None

-fuse-ld=keyword (L*X only)

    Tells the compiler to use a different
        linker instead of the default linker, which is ld on Linux and link on Windows.

    Arguments:

    keyword
        Tells the compiler which non-default linker to use. Possible values are:

        bfd Tells the compiler to use the bfd linker. This setting is only available for Linux.

        gold
            Tells the compiler to use the gold linker. This setting is only available for Linux.

        lld Tells the compiler to use the lld linker.

    Default:

    Linux: ld
        The compiler uses the ld linker by default.

    Windows: link
        The compiler uses the link linker by default.

    Description:

    This option tells the compiler to use a different linker instead of the default linker, which is ld on Linux and link on Windows.

    On Linux, this option is provided for compatibility with gcc.

    NOTE: On Windows, option /Qipo automatically sets option -fuse-ld=lld.

    NOTE: This option only applies to host compilation. When offloading is enabled, it does not impact device-specific compilation.

    Alternate Options:

    None

-fvec-peel-loops (L*X only)

-fno-vec-peel-loops (L*X only)

    Enables peel loop vectorization.

    Arguments:

    None

    Default:

    -fno-vec-peel-loops
        No peel loop vectorization occurs.

    Description:

    This option enables vectorization of peeling loops created during loop vectorization. It causes the compiler to perform additional steps to vectorize a peel loop that was created to improve alignment of memory references in the main vectorized loop.

    The peel loop can be vectorized only when the masked mode of vectorization is enabled by specifying option -fvec-with-mask or /Qvec-with-mask.

    The vectorization of a peel loop cannot be enforced because the compiler uses the cost model to determine whether it should be done.

    Alternate Options:

    None

-fvec-remainder-loops (L*X only)

-fno-vec-remainder-loops (L*X only)

    Enables remainder loop vectorization.

    Arguments:

    None

    Default:

    -fno-vec-remainder-loops
        No remainder loop vectorization occurs.

    Description:

    This option enables vectorization of remainder loops created during loop vectorization. It causes the compiler to perform additional steps to vectorize the remainder loop that was created for the vectorized main loop.

    The compiler uses the cost model to determine vector factor and mode of vectorization for remainder loops.

    The vectorization of remainder can be enforced using #pragma vector vecremainder on the loop.

    Alternate Options:

    None

-fvec-with-mask (L*X only)

-fno-vec-with-mask (L*X only)

    Enables vectorization for short
        trip-count loops with masking.

    Arguments:

    None

    Default:

    -fno-vec-with-mask
        No vectorization for short trip-count loops with masking occurs.

    Description:

    This option enables a special mode of vectorization, which is applicable for loops with small number of iterations known at compile time. The peeling and remainder loops created during vectorization also fit into this category.

    In this mode, the compiler uses a vector factor that is the lowest power-of-two integer greater than the known (maximum) number of loop iterations. Usually, such vectorized loops have one iteration with most of operations masked.

    Alternate Options:

    None

-fverbose-asm (L*X only)

-fno-verbose-asm (L*X only)

    Produces an assembly listing with
        compiler comments, including options and version information.

    Arguments:

    None

    Default:

    -fno-verbose-asm
        No source code annotations appear in the assembly listing file, if one is produced.

    Description:

    This option produces an assembly listing file with compiler comments, including options and version information.

    To use this option, you must also specify -S, which sets -fverbose-asm.

    If you do not want this default when you specify -S, specify -fno-verbose-asm.

    NOTE: This option only applies to host compilation. When offloading is enabled, it does not impact device-specific compilation.

    Alternate Options:

    None

-fvisibility=arg (L*X only)

-fvisibility-global-new-delete-hidden (L*X only)

-fvisibility-inlines-hidden (L*X only)

-f[no]visibility-inlines-hidden-static-local-var (L*X only)

-fvisibility-ms-compat (L*X only)

    Specifies the default visibility for
        global symbols or the visibility for symbols in declarations, functions, or variables.

    Arguments:

    arg Specifies the visibility setting. Possible values are:

        default
            Sets visibility to default. The symbol is visible outside this shared object.

            This means that other components can reference the symbols, and the symbol definitions can be overridden (preempted) by a definition of the same name in another component.

        hidden
            Sets visibility to hidden. The symbol is not visible outside this shared object.

            This means that other components cannot directly reference the symbol.

        internal
            This is the same as specifying hidden.

        protected
            Sets visibility to protected. The symbol is seen by the dynamic linker but always dynamically resolves to an object within this shared object.

            This means that other components can reference the symbol, but it cannot be overridden by a definition of the same name in another component.

            This value is not supported on all targets.

    Default:

    -fvisibility=default
        The compiler sets visibility of symbols to default.

    Description:

    This option specifies the default visibility for global symbols (syntax -fvisibility=arg) or the visibility for symbols in declarations, functions, or variables.

    The following table shows supported -fvisibility options:

    Option
        Description

    -fvisibility=arg
        Sets visibility of symbols for all global declarations.

    As specified above in Arguments,
        arg can be one of the following: hidden internal default protected.

    -fvisibility-global-new-delete-hidden
        Sets hidden visibility for global C++ operator new and delete declarations.

    -fvisibility-inlines-hidden
        Sets hidden visibility by default for inline C++ member functions.

    -fvisibility-inlines-hidden-static-local-var -fno-visibility-inlines-hidden-static-local-var
        When -fvisibility-inlines-hidden is enabled, static variables in inline C++ member functions will also be given hidden visibility by default.

    To disable option
        -fvisibility-inlines-hidden-static-local-var, specify option -fno-visibility-inlines-hidden-static-local-var.

    -fvisibility-ms-compat
        Sets default visibility for global types and sets hidden visibility for global functions and variables.

    If an -fvisibility option is specified more than once on the command line, the last specification takes precedence over any others.

    The following shows the precedence of the visibility settings (from greatest to least visibility):

    •   default

    •   protected

    •   hidden

    Alternate Options:

    None

-fzero-initialized-in-bss (L*X only)

-fno-zero-initialized-in-bss (L*X only)

    Determines whether the compiler places
        in the DATA section any variables explicitly initialized with zeros.

    Arguments:

    None

    Default:

    -fno-zero-initialized-in-bss
        Variables explicitly initialized with zeros are placed in the BSS section. This can save space in the resulting code.

    Description:

    This option determines whether the compiler places in the DATA section any variables explicitly initialized with zeros.

    If option -fno-zero-initialized-in-bss (Linux*) or /Qzero-initialized-in-bss- (Windows*) is specified, the compiler places in the DATA section any variables that are initialized to zero.

    Alternate Options:

    None

-g[n] (L*X only)

    Tells the compiler to generate a level of
        debugging information in the object file.

    Arguments:

    n   Is the level of debugging information to be generated. Possible values are:

        0   Disables generation of symbolic debug information.

        1   Produces minimal debug information for performing stack traces.

        2   Produces complete debug information. This is the same as specifying -g with no n.

        3   Produces extra information that may be useful for some tools.

    Default:

    -g or -g2
        The compiler produces complete debug information.

    Description:

    Option -g tells the compiler to generate symbolic debugging information in the object file, which increases the size of the object file.

    The compiler does not support the generation of debugging information in assemblable files. If you specify this option, the resulting object file will contain debugging information, but the assemblable file will not.

    This option turns off option -O2 and makes option -O0 the default unless option -O2 (or higher) is explicitly specified in the same command line.

    Specifying the -g or -O0 option sets the -fno-omit-frame-pointer option.

    NOTE: When option -g is specified, debugging information is generated in the DWARF Version 3 format. Older versions of some analysis tools may require applications to be built with the -gdwarf-2 option to ensure correct operation.

    Alternate Options:

    Linux: None

    Windows: /Zi, /Z7, /ZI

--gcc-toolchain=dir (L*X only)

    Lets you specify the location of the base
        toolchain.

    Arguments:

    dir Is the location of the base toolchain.

    Default:

    OFF The compiler uses heuristics to locate the base toolchain.

    Description:

    This option lets you specify the location of the base toolchain.

    NOTE: This option only applies to host compilation. When offloading is enabled, it does not impact device-specific compilation.

    Alternate Options:

    None

-gdwarf-n (L*X only)

    Lets you specify a DWARF Version format
        when generating debug information.

    Arguments:

    n   Is a value denoting the DWARF Version format to use. Possible values are:

        2   Generates debug information using the DWARF Version 2 format.

        3   Generates debug information using the DWARF Version 3 format.

        4   Generates debug information using the DWARF Version 4 format.

        5   Generates debug information using the DWARF Version 5 format.

    Default:

    OFF No debug information is generated. However, if compiler option -g is specified, debugging information is generated in the DWARF Version 4 format.

    Description:

    This option lets you specify a DWARF Version format when generating debug information.

    Note that older versions of some analysis tools may require applications to be built with the -gdwarf-2 option to ensure correct operation.

    Alternate Options:

    None

-grecord-gcc-switches (L*X only)

    Causes the command line options that
        were used to invoke the compiler to be appended to the DW_AT_producer attribute in DWARF debugging information.

    Arguments:

    None

    Default:

    OFF The command line options that were used to invoke the compiler are not appended to the DW_AT_producer attribute in DWARF debugging information.

    Description:

    This option causes the command line options that were used to invoke the compiler to be appended to the DW_AT_producer attribute in DWARF debugging information.

    The options are concatenated with whitespace separating them from each other and from the compiler version.

    Alternate Options:

    None

-gsplit-dwarf (L*X only)

    Creates a separate object file containing
        DWARF debug information.

    Arguments:

    None

    Default:

    OFF No separate object file containing DWARF debug information is created.

    Description:

    This option creates a separate object file containing DWARF debug information. It causes debug information to be split between the generated object (.o) file and the new DWARF object (.dwo) file.

    The DWARF object file is not used by the linker, so this reduces the amount of debug information the linker must process and it results in a smaller executable file.

    For this option to perform correctly, you must use binutils-2.24 or higher. To debug the resulting executable, you must use gdb-7.6.1 or higher.

    NOTE: If you use the split executable with a tool that does not support the split DWARF format, it will behave as though the DWARF debug information is absent.

    NOTE: This option only applies to host compilation. When offloading is enabled, it does not impact device-specific compilation.

    Alternate Options:

    None

-H (L*X only)

    Tells the compiler to display the include
        file order and continue compilation.

    Arguments:

    None

    Default:

    OFF Compilation occurs as usual.

    Description:

    This option tells the compiler to display the include file order and continue compilation.

    Alternate Options:

    None

-help (L*X only)

    Displays a list of supported compiler
        options in alphabetical order.

    Arguments:

    None

    Default:

    OFF No list is displayed unless this compiler option is specified.

    Description:

    This option displays a list of supported compiler options in alphabetical order.

    NOTE: This option only applies to host compilation. When offloading is enabled, it does not impact device-specific compilation.

    Alternate Options:

    None

-Idir (L*X only)

    Specifies an additional directory to
        search for include files.

    Arguments:

    dir Is the additional directory for the search.

    Default:

    OFF The default directory is searched for include files.

    Description:

    This option specifies an additional directory to search for include files. To specify multiple directories on the command line, repeat the include option for each directory.

    Alternate Options:

    None

-I- (L*X only)

    Splits the include path.

    Arguments:

    None

    Default:

    OFF The default directory is searched for include files.

    Description:

    This option splits the include path. It prevents the use of the current directory as the first search directory for '#include "file"'.

    If you specify directories using the I option before you specify option I-, the directories are searched only for the case of '#include "file"'; they are not searched for '#include <file>'.

    If you specify directories using the I option after you specify option I-, these directories are searched for all '#include' directives.

    This option has no effect on option nostdinc++, which searches the standard system directories for header files.

    This option is provided for compatibility with gcc.

    Alternate Options:

    None

-idirafterdir (L*X only)

    Adds a directory to the second include
        file search path.

    Arguments:

    dir Is the name of the directory to add.

    Default:

    OFF Include file search paths include certain default directories.

    Description:

    This option adds a directory to the second include file search path (after -I).

    Alternate Options:

    None

-imacros filename (L*X only)

    Allows a header to be specified that is
        included in front of the other headers in the translation unit.

    Arguments:

    filename
        Name of header file.

    Default:

    OFF

    Description:

    Allows a header to be specified that is included in front of the other headers in the translation unit.

    Alternate Options:

    None

-ipo[n] (L*X only)

-no-ipo (L*X only)

    Enables interprocedural optimization
        between files.

    Arguments:

    n   Is an optional integer that specifies the number of object files the compiler should create. The integer must be greater than or equal to 0.

    Default:

    -no-ipo or
        /Qipo- Multifile interprocedural optimization is not enabled.

    Description:

    This option enables interprocedural optimization between files. This is also called multifile interprocedural optimization (multifile IPO) or Whole Program Optimization (WPO).

    When you specify this option, the compiler performs inline function expansion for calls to functions defined in separate files.

    You cannot specify the names for the files that are created.

    If n is 0, the compiler decides whether to create one or more object files based on an estimate of the size of the application. It generates one object file for small applications, and two or more object files for large applications.

    If n is greater than 0, the compiler generates n object files, unless n exceeds the number of source files (m), in which case the compiler generates only m object files.

    If you do not specify n, the default is 0.

    NOTE: When you specify option [Q]ipo with option [q or Q]opt-report, IPO information is generated in the compiler optimization report at link time. After linking, you will see a report named ipo_out.optrpt in the folder where you linked all of the object files.

    NOTE: On Windows, option /Qipo automatically sets option -fuse-ld=lld.

    NOTE: This option only applies to host compilation. When offloading is enabled, it does not impact device-specific compilation.

    Alternate Options:

    None

-ipp-link[=lib] (L*X only)

    Controls whether the compiler links to
        static or dynamic threaded Intel(R) Integrated Performance Primitives (Intel(R) IPP) runtime libraries.

    Arguments:

    lib Specifies the Intel(R) IPP library to use. Possible values are:

        static
            Tells the compiler to link to the set of static runtime libraries.

        dynamic
            Tells the compiler to link to the set of dynamic threaded runtime libraries.

    Default:

    dynamic
        The compiler links to the Intel(R) IPP set of dynamic runtime libraries. However, if Linux* option -static is specified, the compiler links to the set of static runtime libraries.

    Description:

    This option controls whether the compiler links to static or dynamic threaded Intel(R) Integrated Performance Primitives (Intel(R) IPP) runtime libraries.

    To use this option, you must also specify the [Q]ipp option.

    NOTE: This option only applies to host compilation. When offloading is enabled, it does not impact device-specific compilation.

    Product and Performance Information

    = = = = = = = = = =

    Performance varies by use, configuration and other factors. Learn more at
        www.Intel.com/PerformanceIndex.

    Notice revision #20201201

    = = = = = = = = = =

    Alternate Options:

    None

-iprefix prefix (L*X only)

    Lets you indicate the prefix for
        referencing directories that contain header files.

    Arguments:

    prefix
        Is the prefix to use.

    Default:

    OFF No prefix is included.

    Description:

    Options for indicating the prefix for referencing directories containing header files. Use prefix with option -iwithprefix as a prefix.

    Alternate Options:

    None

-iquote dir (L*X only)

    Adds a directory to the front of the
        include file search path for files included with quotes but not brackets.

    Arguments:

    dir Is the name of the directory to add.

    Default:

    OFF The compiler does not add a directory to the front of the include file search path.

    Description:

    Add directory to the front of the include file search path for files included with quotes but not brackets.

    Alternate Options:

    None

-isystemdir (L*X only)

    Specifies a directory to add to the start
        of the system include path.

    Arguments:

    dir Is the directory to add to the system include path.

    Default:

    OFF The default system include path is used.

    Description:

    This option specifies a directory to add to the system include path. The compiler searches the specified directory for include files after it searches all directories specified by the -I compiler option but before it searches the standard system directories.

    On Linux* systems, this option is provided for compatibility with gcc.

    Alternate Options:

    None

-iwithprefixdir (L*X only)

    Appends a directory to the prefix passed
        in by -iprefix and puts it on the include search path at the end of the include directories.

    Arguments:

    dir Is the include directory.

    Default:

    OFF

    Description:

    This option appends a directory to the prefix passed in by -iprefix and puts it on the include search path at the end of the include directories.

    Alternate Options:

    None

-iwithprefixbeforedir (L*X only)

    Similar to -iwithprefix except the
        include directory is placed in the same place as -I command-line include directories.

    Arguments:

    dir Is the include directory.

    Default:

    OFF

    Description:

    Similar to -iwithprefix except the include directory is placed in the same place as -I command-line include directories.

    Alternate Options:

    None

-Kc++ (L*X only)

    Tells the compiler to process all source
        or unrecognized file types as C++ source files. This is a deprecated option that may be removed in a future release.

    Arguments:

    None

    Default:

    OFF The compiler uses default rules for determining whether a file is a C++ source file.

    Description:

    This option tells the compiler to process all source or unrecognized file types as C++ source files.

    This is a deprecated option that may be removed in a future release. The replacement option for Kc++ is -x c++; the replacement option for /TP is /Tp<file>.

    NOTE: This option only applies to host compilation. When offloading is enabled, it does not impact device-specific compilation.

    Alternate Options:

    Linux: -x c++

    Windows: /Tp

-lstring (L*X only)

    Tells the linker to search for a
        specified library when linking.

    Arguments:

    string
        Specifies the library (libstring) that the linker should search.

    Default:

    OFF The linker searches for standard libraries in standard directories.

    Description:

    This option tells the linker to search for a specified library when linking.

    When resolving references, the linker normally searches for libraries in several standard directories, in directories specified by the L option, then in the library specified by the l option.

    The linker searches and processes libraries and object files in the order they are specified. So, you should specify this option following the last object file it applies to.

    NOTE: This option only applies to host compilation. When offloading is enabled, it does not impact device-specific compilation.

    Alternate Options:

    None

-Ldir (L*X only)

    Tells the linker to search for libraries
        in a specified directory before searching the standard directories.

    Arguments:

    dir Is the name of the directory to search for libraries.

    Default:

    OFF The linker searches the standard directories for libraries.

    Description:

    This option tells the linker to search for libraries in a specified directory before searching for them in the standard directories.

    NOTE: This option only applies to host compilation. When offloading is enabled, it does not impact device-specific compilation.

    Alternate Options:

    None

-mcode (L*X only)

    Tells the compiler which instruction set
        extensions based on CPUID bits it may generate.

    Arguments:

    code
        Indicates the instruction set extensions based on CPUID bits that the compiler may generate.

        Many of the Clang settings for option -m are supported. For more information on Clang settings for option -m, see the Clang documentation.

    Default:

    varies
        If option arch is not specified, the default target architecture supports Intel(R) SSE2 instructions.

    Description:

    This option tells the compiler which instruction set extensions based on CPUID bits it may generate.

    Code generated with these options should execute on any compatible, non-Intel processor with support for the corresponding instruction set.

    NOTE: Options -m and /Qm enable specific sets of instructions based on CPUID bits. If you want to enable all instructions supported by a named microarchitecture, you should use option -march (Linux) or /arch (Windows).

    NOTE: This option only applies to host compilation. When offloading is enabled, it does not impact device-specific compilation.

    Alternate Options:

    None

-M (L*X only)

    Tells the compiler to generate makefile
        dependency lines for each source file.

    Arguments:

    None

    Default:

    OFF The compiler does not generate makefile dependency lines for each source file.

    Description:

    This option tells the compiler to generate makefile dependency lines for each source file, based on the #include lines found in the source file.

    Alternate Options:

    None

-m64 (L*X only)

    Tells the compiler to generate code for a
        specific architecture.

    Arguments:

    None

    Default:

    -m64
        The compiler generates code for Intel(R) 64 architecture.

    Description:

    These options tell the compiler to generate code for a specific architecture.

    On Linux* systems, these options are provided for compatibility with gcc.

    NOTE: This option only applies to host compilation. When offloading is enabled, it does not impact device-specific compilation.

    Alternate Options:

    None

-m80387 (L*X only)

-mno-80387 (L*X only)

    Specifies whether the compiler can use
        x87 instructions.

    Arguments:

    None

    Default:

    -m80387
        The compiler may use x87 instructions.

    Description:

    This option specifies whether the compiler can use x87 instructions.

    If you specify option -mno-80387, it prevents the compiler from using x87 instructions. If the compiler is forced to generate x87 instructions, it issues an error message.

    NOTE: This option only applies to host compilation. When offloading is enabled, it does not impact device-specific compilation.

    Alternate Options:

    -m[no-]x87

-march=processor (L*X only)

    Tells the compiler to generate code for
        processors that support certain features.

    Arguments:

    processor
        Tells the compiler the code it can generate. Possible values are:

        alderlake broadwell cannonlake cascadelake cooperlake goldmont
            goldmont-plus haswell icelake-server ivybridge rocketlake sandybridge sapphirerapids silvermont skylake skylake-avx512 tigerlake tremont May generate instructions for processors that support the specified Intel(R) processor or microarchitecture code name.

        core-avx2
            Generates code for processors that support Intel(R) Advanced Vector Extensions 2 (Intel(R) AVX2), Intel(R) AVX, SSE4.2, SSE4.1, SSE3, SSE2, SSE, and SSSE3 instructions.

        core-avx-i
            Generates code for processors that support Float-16 conversion instructions and the RDRND instruction, Intel(R) Advanced Vector Extensions (Intel(R) AVX), Intel(R) SSE4.2, SSE4.1, SSE3, SSE2, SSE, and SSSE3 instructions.

        corei7-avx
            Generates code for processors that support Intel(R) Advanced Vector Extensions (Intel(R) AVX), Intel(R) SSE4.2, SSE4.1, SSE3, SSE2, SSE, and SSSE3 instructions.

        corei7
            Generates code for processors that support Intel(R) SSE4 Efficient Accelerated String and Text Processing instructions. May also generate code for Intel(R) SSE4 Vectorizing Compiler and Media Accelerator, Intel(R) SSE3, SSE2, SSE, and SSSE3 instructions.

        atom
            Generates code for processors that support MOVBE instructions. May also generate code for SSSE3 instructions and Intel(R) SSE3, SSE2, and SSE instructions.

        core2
            Generates code for the Intel(R) Core(TM)2 processor family.

    Default:

    OFF If option -march is not specified, the compiler may generate Intel(R) SSE2 and SSE instructions.

    Description:

    This option tells the compiler to generate code for processors that support certain features.

    NOTE: This option only applies to host compilation. When offloading is enabled, it does not impact device-specific compilation.

    Product and Performance Information

    = = = = = = = = = =

    Performance varies by use, configuration and other factors. Learn more at
        www.Intel.com/PerformanceIndex.

    Notice revision #20201201

    = = = = = = = = = =

    Alternate Options:

    None

-masm=dialect (L*X only)

    Tells the compiler to generate the
        assembler output file using a selected dialect.

    Arguments:

    dialect
        Is the dialect to use for the assembler output file. Possible values are:

        att Tells the compiler to generate the assembler output file using AT&T* syntax.

        intel
            Tells the compiler to generate the assembler output file using Intel syntax.

    Default:

    -masm=att
        The compiler generates the assembler output file using AT&T* syntax.

    Description:

    This option tells the compiler to generate the assembler output file using a selected dialect.

    NOTE: This option only applies to host compilation. When offloading is enabled, it does not impact device-specific compilation.

    Alternate Options:

    None

-mbranches-within-32B-boundaries (L*X only)

-mno-branches-within-32B-boundaries (L*X only)

    Tells the compiler to align branches and
        fused branches on 32-byte boundaries for better performance.

    Arguments:

    None

    Default:

    -mno-branches-within-32B-boundaries
        Branches and fused branches are not aligned on 32-byte boundaries.

    Description:

    This option tells the compiler to align branches and fused branches on 32-byte boundaries for better performance.

    NOTE: When you use this option, it may affect binary utilities usage experience, such as debugability.

    NOTE: This option only applies to host compilation. When offloading is enabled, it does not impact device-specific compilation.

    Alternate Options:

    None

-mcmodel=mem_model (L*X only)

    Tells the compiler to use a specific
        memory model to generate code and store data.

    Arguments:

    mem_model
        Is the memory model to use. Possible values are:

        small
            Tells the compiler to restrict code and data to the first 2GB of address space. All accesses of code and data can be done with Instruction Pointer (IP)-relative addressing.

        medium
            Tells the compiler to restrict code to the first 2GB; it places no memory restriction on data. Accesses of code can be done with IP-relative addressing, but accesses of data must be done with absolute addressing.

        large
            Places no memory restriction on code or data. All accesses of code and data must be done with absolute addressing.

    Default:

    -mcmodel=small
        On systems using Intel(R) 64 architecture, the compiler restricts code and data to the first 2GB of address space. Instruction Pointer (IP)-relative addressing can be used to access code and data.

    Description:

    This option tells the compiler to use a specific memory model to generate code and store data. It can affect code size and performance. If your program has global and static data with a total size smaller than 2GB, -mcmodel=small is sufficient. Global and static data larger than 2GB requires-mcmodel=medium or -mcmodel=large. Allocation of memory larger than 2GB can be done with any setting of -mcmodel.

    IP-relative addressing requires only 32 bits, whereas absolute addressing requires 64-bits. IP-relative addressing is somewhat faster. So, the small memory model has the least impact on performance.

    Alternate Options:

    None

-MD (L*X only)

    Preprocess and compile, generating output
        file containing dependency information ending with extension .d.

    Arguments:

    None

    Default:

    OFF The compiler does not generate dependency information.

    Description:

    Preprocess and compile, generating output file containing dependency information ending with extension .d.

    Alternate Options:

    None

-MFfilename (L*X only)

    Tells the compiler to generate makefile
        dependency information in a file.

    Arguments:

    filename
        Is the name of the file where the makefile dependency information should be placed.

    Default:

    OFF The compiler does not generate makefile dependency information in files.

    Description:

    This option tells the compiler to generate makefile dependency information in a file. To use this option, you must also specify /QM or /QMM.

    Alternate Options:

    None

-MG (L*X only)

    Tells the compiler to generate makefile
        dependency lines for each source file.

    Arguments:

    None

    Default:

    OFF The compiler does not generate makefile dependency information in files.

    Description:

    This option tells the compiler to generate makefile dependency lines for each source file. It is similar to /QM, but it treats missing header files as generated files.

    Alternate Options:

    None

-mintrinsic-promote (L*X only)

    Enables functions containing calls to
        intrinsics that require a specific CPU feature to have their target architecture automatically promoted to allow the required feature.

    Arguments:

    None

    Default:

    OFF If this option is not specified and you call an intrinsic that requires a CPU feature not provided by the specified (or default) target processor, an error will be reported.

    Description:

    This option enables functions containing calls to intrinsics that require a specific CPU feature to have their target architecture automatically promoted to allow the required feature.

    All code within the function will be compiled with that target architecture, and the resulting code for such functions will not execute correctly on processors that do not support the required feature.

    You are responsible for guarding the execution path at runtime so that such functions are not dynamically reachable when the program is run on processors that do not support the required feature.

    NOTE: We recommend that you use __attribute__((target(<required target>))) to mark functions that are intended to be executed on specific target architectures instead of using this option. This attribute will provide significantly better compile time error checking.

    NOTE: This option only applies to host compilation. When offloading is enabled, it does not impact device-specific compilation.

    Alternate Options:

    None

-MM (L*X only)

    Tells the compiler to generate makefile
        dependency lines for each source file.

    Arguments:

    None

    Default:

    OFF The compiler does not generate makefile dependency information in files.

    Description:

    This option tells the compiler to generate makefile dependency lines for each source file. It is similar to /QM, but it does not include system header files.

    Alternate Options:

    None

-MMD (L*X only)

    Tells the compiler to generate an output
        file containing dependency information.

    Arguments:

    None

    Default:

    OFF The compiler does not generate an output file containing dependency information.

    Description:

    This option tells the compiler to preprocess and compile a file, then generate an output file (with extension information.

    It is similar to /QMD, but it does not include system header files.

    Alternate Options:

    None

-momit-leaf-frame-pointer (L*X only)

-mno-omit-leaf-frame-pointer (L*X only)

    Determines whether the frame pointer is
        omitted or kept in leaf functions.

    Arguments:

    None

    Default:

    Varies
        If you specify option -fomit-frame-pointer (or it is set by default), the default is -momit-leaf-frame-pointer. If you specify option -fno-omit-frame-pointer, the default is -mno-omit-leaf-frame-pointer.

    Description:

    This option determines whether the frame pointer is omitted or kept in leaf functions. It is related to option -f[no-]omit-frame-pointer and the setting for that option has an effect on this option.

    Consider the following option combinations:

    Option Combination
        Result

    -fomit-frame-pointer -momit-leaf-frame-pointer

    or

    -fomit-frame-pointer
        -mno-omit-leaf-frame-pointer Both combinations are the same as specifying -fomit-frame-pointer. Frame pointers are omitted for all routines.

    -fno-omit-frame-pointer -momit-leaf-frame-pointer
        In this case, the frame pointer is omitted for leaf routines, but other routines will keep the frame pointer.

    This is the intended effect of option
        -momit-leaf-frame-pointer.

    -fno-omit-frame-pointer
        -mno-omit-leaf-frame-pointer In this case, -mno-omit-leaf-frame-pointer is ignored since -fno-omit-frame-pointer retains frame pointers in all routines .

    This combination is the same as specifying
        -fno-omit-frame-pointer.

    This option is provided for compatibility with gcc.

    NOTE: This option only applies to host compilation. When offloading is enabled, it does not impact device-specific compilation.

    Alternate Options:

    None

-MQtarget (L*X only)

    Changes the default target rule for
        dependency generation.

    Arguments:

    target
        Is the target rule to use.

    Default:

    OFF The default target rule applies to dependency generation.

    Description:

    This option changes the default target rule for dependency generation. It is similar to -MT, but quotes special Make characters.

    Alternate Options:

    None

-MTtarget (L*X only)

    Changes the default target rule for
        dependency generation.

    Arguments:

    target
        Is the target rule to use.

    Default:

    OFF The default target rule applies to dependency generation.

    Description:

    This option changes the default target rule for dependency generation.

    Alternate Options:

    None

-mtune=processor (L*X only)

    Performs optimizations for specific
        processors but does not cause extended instruction sets to be used (unlike -march).

    Arguments:

    processor
        Is the processor for which the compiler should perform optimizations. Possible values are:

        generic
            Optimizes code for the compiler's default behavior.

        alderlake broadwell cannonlake cascadelake  cooperlake goldmont goldmont-plus haswell
            icelake-server ivybridge rocketlake sandybridge sapphirerapids silvermont skylake skylake-avx512 tigerlake tremont Optimizes code for processors that support the specified Intel(R) processor or microarchitecture code name.

        core-avx2
            Optimizes code for processors that support Intel(R) Advanced Vector Extensions 2 (Intel(R) AVX2), Intel(R) AVX, SSE4.2, SSE4.1, SSE3, SSE2, SSE, and SSSE3 instructions.

        core-avx-i
            Optimizes code for processors that support Float-16 conversion instructions and the RDRND instruction, Intel(R) Advanced Vector Extensions (Intel(R) AVX), Intel(R) SSE4.2, SSE4.1, SSE3, SSE2, SSE, and SSSE3 instructions.

        corei7-avx
            Optimizes code for processors that support Intel(R) Advanced Vector Extensions (Intel(R) AVX), Intel(R) SSE4.2, SSE4.1, SSE3, SSE2, SSE, and SSSE3 instructions.

        corei7
            Optimizes code for processors that support Intel(R) SSE4 Efficient Accelerated String and Text Processing instructions. May also generate code for Intel(R) SSE4 Vectorizing Compiler and Media Accelerator, Intel(R) SSE3, SSE2, SSE, and SSSE3 instructions.

        atom
            Optimizes code for processors that support MOVBE instructions. May also generate code for SSSE3 instructions and Intel(R) SSE3, SSE2, and SSE instructions.

        core2
            Optimizes for the Intel(R) Core(TM)2 processor family, including support for MMX(TM), Intel(R) SSE, SSE2, SSE3, and SSSE3 instruction sets.

    Default:

    generic
        Code is generated for the compiler's default behavior.

    Description:

    This option performs optimizations for specific processors but does not cause extended instruction sets to be used (unlike -march).

    The resulting executable is backwards compatible and generated code is optimized for specific processors. For example, code generated with -mtune=core2 or /tune:core2 runs correctly on 4th Generation Intel(R) Core(TM) processors, but it might not run as fast as if it had been generated using -mtune=haswell or /tune:haswell.

    Code generated with -mtune=haswell (/tune:haswell) or -mtune=core-avx2 (/tune:core-avx2) will also run correctly on Intel(R) Core(TM)2 processors, but it might not run as fast as if it had been generated using -mtune=core2 or /tune:core2.

    This is in contrast to code generated with -march=core-avx2, which will not run correctly on older processors such as Intel(R) Core(TM)2 processors.

    NOTE: This option only applies to host compilation. When offloading is enabled, it does not impact device-specific compilation.

    Product and Performance Information

    = = = = = = = = = =

    Performance varies by use, configuration and other factors. Learn more at
        www.Intel.com/PerformanceIndex.

    Notice revision #20201201

    = = = = = = = = = =

    Alternate Options:

    None

-no-libgcc (L*X only)

    Prevents the linking of certain
        gcc-specific libraries.

    Arguments:

    None

    Default:

    OFF

    Description:

    This option prevents the linking of certain gcc-specific libraries.

    This option is not recommended for general use.

    NOTE: This option only applies to host compilation. When offloading is enabled, it does not impact device-specific compilation.

    Alternate Options:

    None

-nodefaultlibs (L*X only)

    Prevents the compiler from using standard
        libraries when linking.

    Arguments:

    None

    Default:

    OFF The standard libraries are linked.

    Description:

    This option prevents the compiler from using standard libraries when linking.

    On Linux* systems, it is provided for GNU compatibility.

    NOTE: This option only applies to host compilation. When offloading is enabled, it does not impact device-specific compilation.

    Alternate Options:

    None

-no-intel-lib[=library] (L*X only)

    Disables linking to specified Intel(R)
        libraries, or to all Intel(R) libraries.

    Arguments:

    library
        Indicates which Intel(R) library should not be linked. Possible values are:

        libirc
            Disables linking to the Intel(R) C/C++ library.

        libimf
            Disables linking to the Intel(R) oneAPI DPC++/C++ Compiler Math library.

        libm
            This setting is only available on Windows. It is equivalent to specifying libimf.

        libsvml
            Disables linking to the Intel(R) Short Vector Math library.

        libirng
            Disables linking to the Random Number Generator library.

    If you specify more than one library, they must be separated by commas.

    If library is omitted, the compiler will not link to any of the Intel(R) libraries shown above.

    Default:

    OFF If this option is not specified, the compiler uses default heuristics for linking to libraries.

    Description:

    This option disables linking to specified Intel(R) libraries, or to all Intel(R) libraries.

    NOTE: This option only applies to host compilation. When offloading is enabled, it does not impact device-specific compilation.

    Alternate Options:

    None

-nolib-inline (L*X only)

    Disables inline expansion of standard
        library or intrinsic functions.

    Arguments:

    None

    Default:

    OFF The compiler inlines many standard library and intrinsic functions.

    Description:

    This option disables inline expansion of standard library or intrinsic functions. It prevents the unexpected results that can arise from inline expansion of these functions.

    NOTE: This option only applies to host compilation. When offloading is enabled, it does not impact device-specific compilation.

    Alternate Options:

    None

-nolibsycl (L*X only)

    Disables linking of the SYCL* runtime
        library.

    Arguments:

    None

    Default:

    OFF The SYCL* runtime library is linked.

    Description:

    This option disables linking of the SYCL* runtime library.

    When using the icx/icpx compiler driver, this option is only effective if you have specified option -fsycl.

    NOTE: This option only applies to host compilation. When offloading is enabled, it does not impact device-specific compilation.

    Alternate Options:

    None

-nostartfiles (L*X only)

    Prevents the compiler from using standard
        startup files when linking.

    Arguments:

    None

    Default:

    OFF The compiler uses standard startup files when linking.

    Description:

    This option prevents the compiler from using standard startup files when linking.

    NOTE: This option only applies to host compilation. When offloading is enabled, it does not impact device-specific compilation.

    Alternate Options:

    None

-nostdinc++ (L*X only)

    Do not search for header files in the
        standard directories for C++, but search the other standard directories.

    Arguments:

    None

    Default:

    OFF

    Description:

    Do not search for header files in the standard directories for C++, but search the other standard directories.

    Alternate Options:

    None

-nostdlib (L*X only)

    Prevents the compiler from using standard
        libraries and startup files when linking.

    Arguments:

    None

    Default:

    OFF The compiler uses standard startup files and standard libraries when linking.

    Description:

    This option prevents the compiler from using standard libraries and startup files when linking.

    This option is provided for GNU compatibility.

    NOTE: This option only applies to host compilation. When offloading is enabled, it does not impact device-specific compilation.

    Alternate Options:

    None

-o  filename (L*X only)

    Specifies the name for an output file.

    Arguments:

    filename
        Is the name for the output file. The space before filename is optional.

    Default:

    OFF The compiler uses the default file name for an output file.

    Description:

    This option specifies the name for an output file as follows:

    •   If -c is specified, it specifies the name of the generated object file.

    •   If -S is specified, it specifies the name of the generated assembly listing file.

    •   If -P is specified, it specifies the name of the generated preprocessor file.

    Otherwise, it specifies the name of the executable file.

    Alternate Options:

    Linux: None

    Windows: /Fe

-O[n] (L*X only)

    Specifies the code optimization for
        applications.

    Arguments:

    n   Is the optimization level. Possible values are 1, 2, or 3. On Linux* systems, you can also specify 0.

    Default:

    O2  Optimizes for code speed. This default may change depending on which other compiler options are specified. For details, see below.

    Description:

    This option specifies the code optimization for applications.

    Option
        Description

    O (Linux*)
        This is the same as specifying O2.

    O0 (Linux)
        Disables all optimizations.

    This option may set other options. This is
        determined by the compiler, depending on which operating system and architecture you are using. The options that are set may change from release to release.

    O1  Enables optimizations for speed and disables some optimizations that increase code size and affect speed. To limit code size, this option:

        •   Enables global optimization; this includes data-flow analysis, code motion, strength reduction and test replacement, split-lifetime analysis, and instruction scheduling.

        •   Disables inlining of some intrinsics.

    This option may set other options. This is
        determined by the compiler, depending on which operating system and architecture you are using. The options that are set may change from release to release.

    The O1 option may improve performance for applications with very large code size, many branches, and execution time not dominated by code within loops.

    O2  Enables optimizations for speed. This is the generally recommended optimization level. Vectorization is enabled at O2 and higher levels.

    This option also enables:

        •   Inlining of intrinsics

        •   Intra-file interprocedural optimization, which includes:

            •   inlining

            •   constant propagation

            •   forward substitution

            •   routine attribute propagation

            •   variable address-taken analysis

            •   dead static function elimination

            •   removal of unreferenced variables

        •   The following capabilities for performance gain:

            •   constant propagation

            •   copy propagation

            •   dead-code elimination

            •   global register allocation

            •   global instruction scheduling and control speculation

            •   loop unrolling

            •   optimized code selection

            •   partial redundancy elimination

            •   strength reduction/induction variable simplification

            •   variable renaming

            •   exception handling optimizations

            •   tail recursions

            •   peephole optimizations

            •   structure assignment lowering and optimizations

            •   dead store elimination

    This option may set other options, especially
        options that optimize for code speed. This is determined by the compiler, depending on which operating system and architecture you are using. The options that are set may change from release to release.

    Many routines in the shared libraries are more
        highly optimized for Intel(R) microprocessors than for non-Intel microprocessors.

    O3  Performs O2 optimizations and enables more aggressive loop transformations such as Fusion, Block-Unroll-and-Jam, and collapsing IF statements.

    This option may set other options. This is
        determined by the compiler, depending on which operating system and architecture you are using. The options that are set may change from release to release.

    The O3 optimizations may not cause higher performance unless loop and memory access transformations take place. The optimizations may slow down code in some cases compared to O2 optimizations.

    The O3 option is recommended for applications that have loops that heavily use floating-point calculations and process large data sets.

    Many routines in the shared libraries are more
        highly optimized for Intel(R) microprocessors than for non-Intel microprocessors.

    The last O option specified on the command line takes precedence over any others.

    Alternate Options:

    O0  Linux: None Windows: /Od

-Ofast (L*X only)

    Sets certain aggressive options to
        improve the speed of your application.

    Arguments:

    None

    Default:

    OFF The aggressive optimizations that improve speed are not enabled.

    Description:

    This option improves the speed of your application.

    This option is provided for compatibility with gcc.

    NOTE: This option only applies to host compilation. When offloading is enabled, it does not impact device-specific compilation.

    Alternate Options:

    None

-Os (L*X only)

    Enables optimizations that do not
        increase code size; it produces smaller code size than O2.

    Arguments:

    None

    Default:

    OFF Optimizations are made for code speed. However, if O1 is specified, Os is the default.

    Description:

    This option enables optimizations that do not increase code size; it produces smaller code size than O2. It disables some optimizations that increase code size for a small speed benefit.

    This option tells the compiler to favor transformations that reduce code size over transformations that produce maximum performance.

    Alternate Options:

    None

-P (L*X only)

    Tells the compiler to stop the
        compilation process and write the results to a file.

    Arguments:

    None

    Default:

    OFF Normal compilation is performed.

    Description:

    This option tells the compiler to stop the compilation process after C or C++ source files have been preprocessed and write the results to files named according to the compiler's default file-naming conventions.

    On Linux systems, this option causes the preprocessor to expand your source module and direct the output to a stdout. Unlike the -E option, the output from -P on Linux does not include #line number directives. By default, the preprocessor creates the name of the output file using the prefix of the source file name with a by using the -o option.

    Alternate Options:

    Linux: -F

    Windows: None

-pcn (L*X only)

    Enables control of floating-point
        significand precision.

    Arguments:

    n   Is the floating-point significand precision. Possible values are:

        32  Rounds the significand to 24 bits (single precision).

        64  Rounds the significand to 53 bits (double precision).

        80  Rounds the significand to 64 bits (extended precision).

    Default:

    -pc80
        On Linux* systems, the floating-point significand is rounded to 64 bits.

    Description:

    This option enables control of floating-point significand precision.

    Some floating-point algorithms are sensitive to the accuracy of the significand, or fractional part of the floating-point value. For example, iterative operations like division and finding the square root can run faster if you lower the precision with this option.

    Note that a change of the default precision control or rounding mode, for example, by using the [Q]pc32 option or by user intervention, may affect the results returned by some of the mathematical functions.

    Alternate Options:

    None

-pie (L*X only)

-no-pie (L*X only)

    Determines whether the compiler
        generates position-independent code that will be linked into an executable.

    Arguments:

    None

    Default:

    -no-pie
        The compiler does not generate position-independent code that will be linked into an executable.

    Description:

    This option determines whether the compiler generates position-independent code that will be linked into an executable. To enable generation of position-independent code that will be linked into an executable, specify -pie.

    To disable generation of position-independent code that will be linked into an executable, specify -no-pie.

    Alternate Options:

    None

-pragma-optimization-level=interpretation (L*X only)

    Specifies which interpretation of the
        optimization_level pragma should be used if no prefix is specified.

    Arguments:

    interpretation
        Compiler-specific interpretation of optimization_level pragma. Possible values are:

        Intel
            Specify the Intel interpretation.

        GCC Specify the GCC interpretation.

    Default:

    -pragma-optimization-level=Intel
        Use the Intel interpretation of the optimization_level pragma.

    Description:

    Specifies which interpretation of the optimization_level pragma should be used if no prefix is specified.

    NOTE: This option only applies to host compilation. When offloading is enabled, it does not impact device-specific compilation.

    Alternate Options:

    None

-pthread (L*X only)

    Tells the compiler to use pthreads
        library for multithreading support.

    Arguments:

    None

    Default:

    OFF The compiler does not use pthreads library for multithreading support.

    Description:

    Tells the compiler to use pthreads library for multithreading support.

    NOTE: This option only applies to host compilation. When offloading is enabled, it does not impact device-specific compilation.

    Alternate Options:

    None

-qactypes (L*X only)

    Tells the compiler to include the
        Algorithmic C (AC) data type folder for header searches and link to the AC data types libraries for Field Programmable Gate Array (FPGA) and CPU compilations.

    Arguments:

    None

    Default:

    OFF The compiler does not search the Algorithmic C (AC) data type folders for headers and doesn’t link to AC data type libraries for FPGA and CPU compilations. As a result, AC data types cannot be used in the source program.

    Description:

    This option tells the compiler to include the Algorithmic C (AC) data type folder when searching for headers, and to link to the AC data types libraries for Field Programmable Gate Array (FPGA) and CPU compilations.

    AC data types provide support for arbitrary precision integers, fixed precision integers and arbitrary precision floating-point data types. They are built on top of the _ExtInt extended-integer type class.

    When you specify option [q or Q]actypes, dynamic linking is the default. You cannot link to the AC data type libraries statically.

    Linux

    The driver must add the library names explicitly to the link command. You must use option -qactypes to perform the link to pull in the dependent libraries.

    Windows

    This option adds directives to the compiled code, which the linker then reads without further input from the driver. You do not need to specify a separate link command.

    NOTE: This option only applies to host compilation. When offloading is enabled, it does not impact device-specific compilation.

    Alternate Options:

    None

-qdaal[=lib] (L*X only)

    Tells the compiler to link to certain
        libraries in the Intel(R) oneAPI Data Analytics Library (oneDAL).

    Arguments:

    lib Indicates which oneDAL library files should be linked. Possible values are:

        parallel
            Tells the compiler to link using the threaded oneDAL libraries. This is the default if the option is specified with no lib.

        sequential
            Tells the compiler to link using the non-threaded oneDAL libraries.

    Default:

    OFF The compiler does not link to the oneDAL.

    Description:

    This option tells the compiler to link to certain libraries in the Intel(R) oneAPI Data Analytics Library (oneDAL).

    On Linux* systems, the associated oneDAL headers are included when you specify this option.

    NOTE: On Windows* systems, this option adds directives to the compiled code, which the linker then reads without further input from the driver. You do not need to specify a separate link command.

    On Linux* systems, the driver must add the library names explicitly to the link command. You must use option -qdaal to perform the link to pull in the dependent libraries.

    Product and Performance Information

    = = = = = = = = = =

    Performance varies by use, configuration and other factors. Learn more at
        www.Intel.com/PerformanceIndex.

    Notice revision #20201201

    = = = = = = = = = =

    Alternate Options:

    Linux: -daal (this is a deprecated option)

-qipp[=lib] (L*X only)

    Tells the compiler to link to some or all
        of the Intel(R) Integrated Performance Primitives (Intel(R) IPP) libraries.

    Arguments:

    lib Indicates the Intel(R) IPP libraries that the compiler should link to. Possible values are:

        common
            Tells the compiler to link using the main libraries set. This is the default if the option is specified with no lib.

        crypto
            Tells the compiler to link using the Intel(R) Integrated Performance Primitives Cryptography (Intel(R) IPP Cryptography) libraries.

        nonpic
            (Linux* only) Tells the compiler to link using the version of the libraries that do not have position-independent code.

        nonpic_crypto (Linux only)
            Tells the compiler to link using the Intel(R) IPP Cryptography libraries. It uses the version of the libraries that do not have position-independent code.

    Default:

    OFF The compiler does not link to the Intel(R) IPP libraries.

    Description:

    The option tells the compiler to link to some or all of the Intel(R) IPP libraries and include the Intel(R) IPP headers.

    The [Q]ipp-link option controls whether the compiler links to static, dynamic threaded, or static threaded Intel(R) IPP runtime libraries.

    NOTE: On Windows* systems, this option adds directives to the compiled code, which the linker then reads without further input from the driver. You do not need to specify a separate link command.

    On Linux* systems, the driver must add the library names explicitly to the link command. You must use option qipp to perform the link to pull in the dependent libraries.

    Product and Performance Information

    = = = = = = = = = =

    Performance varies by use, configuration and other factors. Learn more at
        www.Intel.com/PerformanceIndex.

    Notice revision #20201201

    = = = = = = = = = =

    Alternate Options:

    Linux: -qipp (this is a deprecated option)

-qmkl[=lib] (L*X only)

    Tells the compiler to link to certain
        libraries in the Intel(R) oneAPI Math Kernel Library (oneMKL). On Windows systems, you must specify this option at compile time.

    Arguments:

    lib Indicates which oneMKL library files should be linked. Possible values are:

        parallel
            Tells the compiler to link using the threaded libraries in oneMKL. This is the default if the option is specified with no lib.

        sequential
            Tells the compiler to link using the sequential libraries in oneMKL.

        cluster
            Tells the compiler to link using the cluster-specific libraries and the sequential libraries in oneMKL.

    Default:

    OFF The compiler does not link to the oneMKL library.

    Description:

    This option tells the compiler to link to certain libraries in the Intel(R) oneAPI Math Kernel Library (oneMKL).

    On Linux* systems, dynamic linking is the default when you specify -qmkl.

    On C++ systems, to link with oneMKL statically, you must specify:

    On Windows* systems, static linking is the default when you specify /Qmkl. To link with oneMKL dynamically, you must specify:

    /Qmkl /MD

    If both option -qmkl (or /Qmkl) and -qmkl-ilp64 (or /Qmkl-ilp64) are specified on the command line, the rightmost specified option takes precedence.

    For more information about using oneMKL libraries, see the article titled: Intel(R) oneAPI Math Kernel Library Link Line Advisor.

    NOTE: On Windows* systems, this option adds directives to the compiled code, which the linker then reads without further input from the driver. You do not need to specify a separate link command.

    On Linux* systems, the driver must add the library names explicitly to the link command. You must use option -qmkl to perform the link to pull in the dependent libraries.

    NOTE: If you specify option [q or Q]mkl, or -qmkl=parallel or /Qmkl:parallel, and you also specify option [Q]tbb, the compiler links to the standard threaded version of oneMKL.

    However, if you specify [q or Q]mkl, or -qmkl=parallel or /Qmkl:parallel, and you also specify option [Q]tbb and option [q or Q]openmp, the compiler links to the OpenMP* threaded version of oneMKL.

    Alternate Options:

    None

-qmkl-ilp64[=lib] (L*X only)

    Tells the compiler to link to the
        ILP64-specific version of the Intel(R) oneAPI Math Kernel Library (oneMKL). On Windows systems, you must specify this option at compile time.

    Arguments:

    lib Indicates which ILP64-specific oneMKL library files should be linked. Possible values are:

        parallel
            Tells the compiler to link using the threaded libraries in oneMKL. This is the default if the option is specified with no lib.

        sequential
            Tells the compiler to link using the sequential libraries in oneMKL.

        cluster
            Tells the compiler to link using the cluster-specific libraries and the sequential libraries in oneMKL.

    Default:

    OFF The compiler does not link to the oneMKL library.

    Description:

    This option tells the compiler to link to the ILP64-specific version of the Intel(R) oneAPI Math Kernel Library (oneMKL).

    If both option -qmkl-ilp64 (or /Qmkl-ilp64) and -qmkl (or /Qmkl) are specified on the command line, the rightmost specified option takes precedence.

    For more information about using oneMKL libraries, see the article titled: Intel(R) oneAPI Math Kernel Library Link Line Advisor.

    Linux

    Dynamic linking is the default when you specify -qmkl-ilp64.

    On C++ systems, to link with oneMKL statically, you must specify:

    -qmkl-ilp64 -static-intel

    The driver must add the library names explicitly to the link command. You must use option -qmkl-ilp64 to perform the link to pull in the dependent libraries.

    Windows

    Static linking is the default when you specify /Qmkl-ilp64. To link with oneMKL dynamically, you must specify:

    /Qmkl-ilp64 /MD

    This option adds directives to the compiled code, which the linker then reads without further input from the driver. You do not need to specify a separate link command.

    Alternate Options:

    None

-qopenmp (L*X only)

-qno-openmp (L*X only)

    Enables recognition of OpenMP* features
        and tells the parallelizer to generate multi-threaded code based on OpenMP* directives.

    Arguments:

    None

    Default:

    -qno-openmp
        No OpenMP* multi-threaded code is generated by the compiler.

    Description:

    This option enables recognition of OpenMP* features and tells the parallelizer to generate multi-threaded code based on OpenMP* directives. The code can be executed in parallel on both uniprocessor and multiprocessor systems.

    This option works with any optimization level. Specifying no optimization (-O0 on Linux* or /Od on Windows*) helps to debug OpenMP applications.

    Linux

    This option can also be specified as -fopenmp.

    NOTE: Option -fopenmp is not the same as option -qopenmp. Option -fopenmp will not do offloading.

    NOTE: Options that use OpenMP* API are available for both Intel(R) microprocessors and non-Intel microprocessors, but these options may perform additional optimizations on Intel(R) microprocessors than they perform on non-Intel microprocessors.

    The list of major, user-visible OpenMP constructs and features that may perform differently on Intel(R) microprocessors versus non-Intel microprocessors include: locks (internal and user visible), the SINGLE construct, barriers (explicit and implicit), parallel loop scheduling, reductions, memory allocation, thread affinity, and binding.

    Product and Performance Information

    = = = = = = = = = =

    Performance varies by use, configuration and other factors. Learn more at
        www.Intel.com/PerformanceIndex.

    Notice revision #20201201

    = = = = = = = = = =

    Alternate Options:

    Linux: -fiopenmp

-qopenmp-link=library (L*X only)

    Controls whether the compiler links to
        static or dynamic OpenMP* runtime libraries.

    Arguments:

    library
        Specifies the OpenMP library to use. Possible values are:

        static
            Tells the compiler to link to static OpenMP runtime libraries. Note that static OpenMP libraries are deprecated.

        dynamic
            Tells the compiler to link to dynamic OpenMP runtime libraries.

    Default:

    -qopenmp-link=dynamic
        The compiler links to dynamic OpenMP* runtime libraries. However, if Linux* option -static is specified, the compiler links to static OpenMP runtime libraries.

    Description:

    This option controls whether the compiler links to static or dynamic OpenMP* runtime libraries.

    To link to the static OpenMP runtime library (RTL) and create a purely static executable, you must specify -qopenmp-link=static. However, we strongly recommend you use the default setting, -qopenmp-link=dynamic.

    Option -qopenmp-link=dynamic cannot be used in conjunction with option -static. If you try to specify both options together, an error will be displayed.

    NOTE: Compiler options -static-intel and -shared-intel (Linux*) have no effect on which OpenMP runtime library is linked.

    NOTE: On Linux systems, the OpenMP runtime library depends on using libpthread and libc (libgcc when compiled with gcc). Libpthread and libc (libgcc) must both be static or both be dynamic.

    If both libpthread and libc (libgcc) are static, then the static version of the OpenMP runtime should be used. If both libpthread and libc (libgcc) are dynamic, then either the static or dynamic version of the OpenMP

    time may be used.

    NOTE: This option only applies to host compilation. When offloading is enabled, it does not impact device-specific compilation.

    Alternate Options:

    None

-qopenmp-simd (L*X only)

-qno-openmp-simd (L*X only)

    Enables or disables OpenMP* SIMD
        compilation.

    Arguments:

    None

    Default:

    -qno-openmp-simd
        OpenMP* SIMD compilation is disabled.

    Description:

    This option enables or disables OpenMP* SIMD compilation.

    You can use this option if you want to enable or disable the SIMD support with no impact on other OpenMP features. In this case, no OpenMP runtime library is needed to link and the compiler does not need to generate OpenMP runtime initialization code.

    When you specify [q or Q]openmp, it implies [q or Q]openmp-simd.

    If you specify this option with the [q or Q]openmp option, it can impact other OpenMP features.

    Option -qopenmp-simd is equivalent to option -fiopenmp-simd; option /Qopenmp-simd is equivalent to option /Qiopenmp-simd.

    NOTE: Advanced users who prefer to use OpenMP* as it is implemented by the LLVM community, can get most of that functionality by using options -fopenmp and -fopenmp-simd.

    Alternate Options:

    Linux: -fiopenmp-simd

    Windows: /Qiopenmp-simd

-qopenmp-stubs (L*X only)

    Enables compilation of OpenMP* programs
        in sequential mode.

    Arguments:

    None

    Default:

    OFF The library of OpenMP* function stubs is not linked.

    Description:

    This option enables compilation of OpenMP* programs in sequential mode. The OpenMP directives are ignored and a stub OpenMP library is linked.

    NOTE: This option only applies to host compilation. When offloading is enabled, it does not impact device-specific compilation.

    Alternate Options:

    None

-qopt-assume-no-loop-carried-dep[=n] (L*X only)

    Lets you set a level of performance
        tuning for loops.

    Arguments:

    n   Is the action for loop-carried dependencies. Possible values are:

        0   The compiler does not assume there are no loop carried dependencies. This is the default if this option is not specified.

        1   Tells the compiler to assume there are no loop-carried dependencies for innermost loops. This is the default if the option is used but n is not specified.

        2   Tells the compiler to assume there are no loop-carried dependencies for all loop levels.

    Default:

    [q or
        Q]qopt-assume-no-loop-carried-dep=0 The compiler does not assume there are no loop carried dependencies.

    Description:

    This option lets you set a level of performance tuning for loops.

    It is useful for C/C++ applications and benchmarks where pointers and arguments could be aliased. This is because when you specify level 1 or level 2, more loops will be vectorized or benefit from loop transformations.

    This option is applied to all loops in the file. It does not apply to code outside loops.

    Alternate Options:

    None

-qopt-dynamic-align (L*X only)

-qno-opt-dynamic-align (L*X only)

    Enables or disables dynamic data
        alignment optimizations.

    Arguments:

    None

    Default:

    -qno-opt-dynamic-align
        The compiler does not generate code dynamically dependent on alignment.

    Description:

    This option enables or disables dynamic data alignment optimizations.

    If you specify -qno-opt-dynamic-align or /Qopt-dynamic-align-, the compiler generates no code dynamically dependent on alignment. It will not do any optimizations based on data location and results will depend on the data values themselves.

    When you specify [q or Q]qopt-dynamic-align, the compiler may implement conditional optimizations based on dynamic alignment of the input data. These dynamic alignment optimizations may result in different bitwise results for aligned and unaligned data with the same values.

    Dynamic alignment optimizations can improve the performance of some vectorized code, especially for long trip count loops, but there is an associated cost of increased code size and compile time. Disabling such optimizations can improve the performance of some other vectorized code. It may also improve bitwise reproducibility of results, factoring out data location from possible sources of discrepancy.

    Alternate Options:

    None

-qopt-for-throughput[=value] (L*X only)

    Determines how the compiler optimizes for
        throughput depending on whether the program is to run in single-job or multi-job mode.

    Arguments:

    value
        Is one of the values "multi-job" or "single-job". If no value is specified, the default is "multi-job".

    Default:

    OFF If this option is not specified, the compiler will not optimize for throughput performance.

    Description:

    This option determines whether throughput performance optimization occurs for a program that is run as a single job or one that is run in a multiple job environment.

    The memory optimizations for a single job versus multiple jobs can be tuned in different ways by the compiler. For example, the cost model for loop tiling and prefetching are different for a single job versus multiple jobs. When a single job is running, more memory is available and the tunings will be different.

    Alternate Options:

    None

-qopt-mem-layout-trans[=n] (L*X only)

-qno-opt-mem-layout-trans (L*X only)

    Controls the level of memory layout
        transformations performed by the compiler.

    Arguments:

    n   Is the level of memory layout transformations. Possible values are:

        0   Disables memory layout transformations. This is the same as specifying -qno-opt-mem-layout-trans (Linux*) or /Qopt-mem-layout-trans- (Windows*).

        1   Enables basic memory layout transformations.

        2   Enables more memory layout transformations. This is the same as specifying [q or Q]opt-mem-layout-trans with no argument.

        3   Enables more memory layout transformations like copy-in/copy-out of structures for a region of code. This setting should only be used when targeting systems that have more than 4GB of physical memory per core.

        4   Enables more aggressive memory layout transformations. This setting should only be used when targeting systems that have more than 4GB of physical memory per core.

    Default:

    -qopt-mem-layout-trans=2
        The compiler performs moderate memory layout transformations.

    Description:

    This option controls the level of memory layout transformations performed by the compiler. This option can improve cache reuse and cache locality.

    Product and Performance Information

    = = = = = = = = = =

    Performance varies by use, configuration and other factors. Learn more at
        www.Intel.com/PerformanceIndex.

    Notice revision #20201201

    = = = = = = = = = =

    Alternate Options:

    None

-qopt-multiple-gather-scatter-by-shuffles (L*X only)

-qno-opt-multiple-gather-scatter-by-shuffles (L*X only)

    Enables or disables the optimization for
        multiple adjacent gather/scatter type vector memory references.

    Arguments:

    None

    Default:

    varies
        When this option is not specified, the compiler uses default heuristics for optimization.

    Description:

    This option controls the optimization for multiple adjacent gather/scatter type vector memory references. This optimization hint is useful for performance tuning. It tries to generate more optimal software sequences using shuffles.

    If you specify this option, the compiler will apply the optimization heuristics. If you specify -qno-opt-multiple-gather-scatter-by-shuffles or /Qopt-multiple-gather-scatter-by-shuffles-, the compiler will not apply the optimization.

    NOTE: Optimization is affected by optimization compiler options, such as [Q]x, -march (Linux*), and /arch (Windows*).

    Product and Performance Information

    = = = = = = = = = =

    Performance varies by use, configuration and other factors. Learn more at
        www.Intel.com/PerformanceIndex.

    Notice revision #20201201

    = = = = = = = = = =

    Alternate Options:

    None

-qopt-prefetch[=n] (L*X only)

-qno-opt-prefetch (L*X only)

    Enables or disables prefetch insertion
        optimization.

    Arguments:

    n   Is the level of software prefetching optimization desired. Possible values are:

        0   Disables software prefetching. This is the same as specifying -qno-opt-prefetch (Linux*) or /Qopt-prefetch- (Windows*).

        1 to
            5 Enables different levels of software prefetching. If you do not specify a value for n, the default is -qopt-prefetch=2 or /Qopt-prefetch:2. Use lower values to reduce the amount of prefetching.

    Default:

    varies
        The default can change depending on certain option settings.

        If you specify option -qno-opt-prefetch (or /Qopt-prefetch-), or you specify option O0 or O1 explicitly or implicitly, prefetch insertion optimization is disabled.

        If you specify option O2 or above explicitly or implicitly, the default is option -qopt-prefetch=2 (or /Qopt-prefetch:2).

    Description:

    This option enables or disables prefetch insertion optimization. The goal of prefetching is to reduce cache misses by providing hints to the processor about when data should be loaded into the cache.

    This option enables prefetching when higher optimization levels are specified.

    Alternate Options:

    None

-qopt-prefetch-distance=n (L*X only)

    Specifies the prefetch distance to be
        used for compiler-generated prefetches inside loops.

    Arguments:

    n   Is the prefetch distance in terms of the number of (possibly-vectorized) iterations. Possible values are non-negative numbers >=0.

        n = 0 turns off all compiler issued prefetches from memory to L1.

    Default:

    OFF The compiler uses default heuristics to determine the prefetch distance.

    Description:

    This option specifies the prefetch distance to be used for compiler-generated prefetches inside loops. The unit n is the number of iterations. If the loop is vectorized by the compiler, the unit is the number of vectorized iterations.

    The value of n will be used as the distance for prefetches from memory to L1 (for example, the vprefetch0 instruction).

    On Linux systems, this option is ignored if option -qopt-prefetch=0 or option -qno-opt-prefetch is specified.

    On Windows systems, this option is ignored if option /Qopt-prefetch=0 or option /Qopt-prefetch- is specified.

    Alternate Options:

    None

-qopt-prefetch-loads-only (L*X only)

    Specifies that the compiler should only
        prefetch for loads inside the loop and ignore the stores, if any.

    Arguments:

    None

    Default:

    OFF The compiler prefetches for both loads and stores.

    Description:

    This option specifies that the compiler should only prefetch for loads inside the loop and ignore the stores, if any.

    On Linux systems, this option is ignored if option -qopt-prefetch=0 or option -qno-opt-prefetch is specified.

    On Windows systems, this option is ignored if option /Qopt-prefetch=0 or option /Qopt-prefetch- is specified.

    NOTE: This option only applies to host compilation. When offloading is enabled, it does not impact device-specific compilation.

    Alternate Options:

    None

-qopt-report[=arg] (L*X only)

    Enables the generation of a YAML file
        that includes optimization transformation information.

    Arguments:

    arg Determines the level of detail in the report. Possible values are:

        0   Disables generation of an optimization report. This is the default when the option is not specified.

        1   or min Tells the compiler to create a report with minimum details.

        2   or med Tells the compiler to create a report with medium details. This is the default if you do not specify arg.

        3   or max Tells the compiler to create a report with maximum details.

        Levels 1, 2, and 3 (min, med, and max) include all the information of the previous level, as well as potentially some additional information.

    Default:

    OFF No optimization report is generated.

    Description:

    This option enables the generation of a YAML file that includes optimization transformation information.

    The YAML-formatted file provides the optimization information for the source file being compiled. For example:

    icx -fiopenmp -qopt-report foo.c

    This command will generate a file called foo.opt.yaml containing the optimization report messages.

    Use opt-viewer.py (from llvm/tools/opt-viewer) to create html files from the YAML file. For example:

    opt-viewer.py foo.opt.yaml

    You can use any web-browser to open the html file to see the opt-report messages displayed inline with the original. For example:

    Firefox html/foo.c.html source code

    For SYCL compilations, you can also use this option to detail the variables passed to the OpenCL kernel in the optimization report. For example:

    icpx -fsycl -qopt-report foo.cpp

    The above command will generate a YAML-formatted optimization report that contains optimization remarks for the SYCL pass. These remarks will list the OpenCL kernel arguments generated by the compiler for the user-defined SYCL kernels in foo.cpp. The remarks will also provide additional information like name, type, and size for the OpenCL kernel arguments.

    You can then use opt-viewer.py to create html files from the YAML file, and use any web-browser to open the html file to see the opt-report remarks

    Note that the YAML file is used to drive the community llvm-opt-report tool.

    NOTE: This option only applies to host compilation. When offloading is enabled, it does not impact device-specific compilation.

    Alternate Options:

    None

-qopt-report-file=keyword (L*X only)

    Specifies whether the output for the
        generated optimization report goes to a file, stderr, or stdout.

    Arguments:

    keyword
        Specifies where the output for the report goes. You can specify one of the following:

        filename
            Specifies the name of the file where the generated report should go.

        stderr
            Indicates that the generated report should go to stderr.

        stdout
            Indicates that the generated report should go to stdout.

            This setting can also be specified as -qopt-report-stdout (Linux) or /Qopt-report-stdout (Windows).

    Default:

    OFF No optimization report is generated.

    Description:

    This option specifies whether the output for the generated optimization report goes to a file, stderr, or stdout.

    If you use this option, you do not have to specify option [q or Q]opt-report.

    NOTE: This option only applies to host compilation. When offloading is enabled, it does not impact device-specific compilation.

    Alternate Options:

    None

-qopt-streaming-stores=keyword (L*X only)

-qno-opt-streaming-stores (L*X only)

    Enables generation of streaming stores
        for optimization.

    Arguments:

    keyword
        Specifies whether streaming stores are generated. Possible values are:

        always
            Enables generation of streaming stores for optimization. The compiler optimizes under the assumption that the application is memory bound.

            When this option setting is specified, it is your responsibility to also insert any memory barriers (fences) as required to ensure correct memory ordering within a thread or across threads. See the Examples section for one way to do this.

        never
            Disables generation of streaming stores for optimization. Normal stores are performed.

            This setting has the same effect as specifying -qno-opt-streaming-stores or /Qopt-streaming-stores-.

        auto
            Lets the compiler decide which instructions to use.

    Default:

    -qopt-streaming-stores=auto
        The compiler decides whether to use streaming stores or normal stores.

    Description:

    This option enables generation of streaming stores for optimization. This method stores data with instructions that use a non-temporal buffer, which minimizes memory hierarchy pollution.

    This option may be useful for applications that can benefit from streaming stores.

    Alternate Options:

    None

-Qoption,string,options (L*X only)

    Passes options to a specified tool.

    Arguments:

    string
        Is the name of the tool.

    options
        Are one or more comma-separated, valid options for the designated tool.

        Note that certain tools may require that options appear within quotation marks (" ").

    Default:

    OFF No options are passed to tools.

    Description:

    This option passes options to a specified tool.

    If an argument contains a space or tab character, you must enclose the entire argument in quotation marks (" "). You must separate multiple arguments with commas.

    string can be any of the following:

    •   cpp - Indicates the preprocessor for the compiler.

    •   c - Indicates the Intel(R) oneAPI DPC++/C++ Compiler.

    •   asm - Indicates the assembler.

    •   link - Indicates the linker.

    •   prof - Indicates the profiler.

    •   On Windows* systems, the following is also available:

        •   masm - Indicates the Microsoft assembler.

    •   On Linux* systems, the following are also available:

        •   as - Indicates the assembler.

        •   gas - Indicates the GNU assembler.

        •   ld - Indicates the loader.

        •   gld - Indicates the GNU loader.

        •   lib - Indicates an additional library.

        •   crt - Indicates the crt%.o files linked into executables to contain the place to start execution.

    NOTE: This option only applies to host compilation. When offloading is enabled, it does not impact device-specific compilation.

    Alternate Options:

    None

-qtbb (L*X only)

    Tells the compiler to link to the
        Intel(R) oneAPI Threading Building Blocks (oneTBB) libraries.

    Arguments:

    None

    Default:

    OFF The compiler does not link to the oneTBB libraries.

    Description:

    This option tells the compiler to link to the Intel(R) oneAPI Threading Building Blocks (oneTBB) libraries and include the oneTBB headers.

    NOTE: On Windows* systems, this option adds directives to the compiled code, which the linker then reads without further input from the driver. You do not need to specify a separate link command.

    On Linux* systems, the driver must add the library names explicitly to the link command. You must use option -qtbb to perform the link to pull in the dependent libraries.

    Alternate Options:

    Linux: -tbb (this is a deprecated option)

-regcall (L*X only)

    Tells the compiler that the __regcall
        calling convention should be used for functions that do not directly specify a calling convention.

    Arguments:

    None

    Default:

    OFF The __regcall calling convention will only be used if a function explicitly specifies it.

    Description:

    This option tells the compiler that the __regcall calling convention should be used for functions that do not directly specify a calling convention. This calling convention ensures that as many values as possible are passed or returned in registers.

    It ensures that __regcall is the default calling convention for functions in the compilation, unless another calling convention is specified in a declaration.

    This calling convention is ignored if it is specified for a function with variable arguments.

    Note that all __regcall functions must have prototypes.

    Alternate Options:

    None

-reuse-exe=exe-filename (L*X only)

    Tells the compiler to speed up Field
        Programmable Gate Array (FPGA) target compile time by reusing a previously compiled FPGA hardware image.

    Arguments:

    exe-filename
        Is a previously compiled SYCL* binary.

    Default:

    OFF There is no potential compile-time speed up by reusing the executable for the FPGA target.

    Description:

    This option tells the compiler to speed up FPGA target compile time by reusing a previously compiled FPGA hardware image. This option is useful only when compiling for hardware.

    It lets you minimize or avoid long Intel(R) Quartus(R) Prime Software compile times for FPGA targets when the device code is unchanged.

    NOTE: When offloading is enabled, this option only applies to device-specific compilation.

    Alternate Options:

    None

-S (L*X only)

    Causes the compiler to compile to an
        assembly file only and not link.

    Arguments:

    None

    Default:

    OFF Normal compilation and linking occur.

    Description:

    This option causes the compiler to compile to an assembly file only and not link.

    On Linux* systems, the assembly file name has a .s suffix. On Windows* systems, the assembly file name has an .asm suffix.

    Alternate Options:

    Linux: None

-save-temps (L*X only)

-no-save-temps (L*X only)

None (SYCL only)

    Tells the compiler to save intermediate
        files created during compilation.

    Arguments:

    None

    Default:

    SYCL: Linux
        systems: -no-save-temps On Linux systems, the compiler deletes intermediate files after compilation is completed.

    Description:

    This option tells the compiler to save intermediate files created during compilation. The names of the files saved are based on the name of the source file; the files are saved in the current working directory.

    If option save-temps (SYCL) is specified, the following occurs:

    •   The object .o file (Linux) is saved.

    •   The .obj file (Windows) object .o file is saved.

    If -no-save-temps is specified on Linux systems, the following occurs:

    •   The .o file is put into /tmp and deleted after calling ld.

    •   The preprocessed file is not saved after it has been used by the compiler.

    NOTE: This option only saves intermediate files that are normally created during compilation.

    Alternate Options:

    None

-shared (L*X only)

    Tells the compiler to produce a dynamic
        shared object instead of an executable.

    Arguments:

    None

    Default:

    OFF The compiler produces an executable.

    Description:

    This option tells the compiler to produce a dynamic shared object (DSO) instead of an executable. This includes linking in all libraries dynamically and passing -shared to the linker.

    You must specify option fpic for the compilation of each object file you want to include in the shared library.

    NOTE: When you specify option shared, the Intel(R) libraries are linked dynamically. If you want them to be linked statically, you must also specify option static-intel.

    NOTE: This option only applies to host compilation. When offloading is enabled, it does not impact device-specific compilation.

    Alternate Options:

    None

-shared-intel (L*X only)

    Causes Intel-provided libraries to be
        linked in dynamically.

    Arguments:

    None

    Default:

    OFF Intel(R) libraries are linked in statically, with the exception of Intel's OpenMP* runtime support library, which is linked in dynamically unless you specify option -qopenmp-link=static.

    Description:

    This option causes Intel-provided libraries to be linked in dynamically. It is the opposite of -static-intel.

    This option is processed by the compiler driver command that initiates linking, adding library names explicitly to the link command.

    If you specify option -mcmodel=medium or -mcmodel=large, it sets option -shared-intel.

    NOTE: This option only applies to host compilation. When offloading is enabled, it does not impact device-specific compilation.

    Alternate Options:

    None

-shared-libgcc (L*X only)

    Links the GNU libgcc library dynamically.

    Arguments:

    None

    Default:

    -shared-libgcc
        The compiler links the libgcc library dynamically.

    Description:

    This option links the GNU libgcc library dynamically. It is the opposite of option static-libgcc.

    This option is processed by the compiler driver command that initiates linking, adding library names explicitly to the link command.

    This option is useful when you want to override the default behavior of the static option, which causes all libraries to be linked statically.

    NOTE: This option only applies to host compilation. When offloading is enabled, it does not impact device-specific compilation.

    Alternate Options:

    None

-sox (L*X only)

    Tells the compiler to save the
        compilation options in the executable file.

    Arguments:

    None

    Default:

    OFF The compiler version number is saved in the object file.

    Description:

    This option tells the compiler to save the compilation options in the executable file. The information is embedded as a string in each object file or assembly output.

    When you specify this option, the size of the executable on disk is increased slightly. When you link the object files into an executable file, the linker places each of the information strings into the header of the executable. It is then possible to use a tool, such as a strings utility, to determine what options were used to build the executable file.

    Alternate Options:

    None

-static (L*X only)

    Prevents linking with shared libraries.

    Arguments:

    None

    Default:

    OFF The compiler links with shared libraries.

    Description:

    This option prevents linking with shared libraries. It causes the executable to link all libraries statically.

    NOTE: This option does not cause static linking of libraries for which no static version is available. These libraries can only be linked dynamically.

    NOTE: This option only applies to host compilation. When offloading is enabled, it does not impact device-specific compilation.

    Alternate Options:

    None

-static-intel (L*X only)

    Causes Intel-provided libraries to be
        linked in statically.

    Arguments:

    None

    Default:

    ON  Intel(R) libraries are linked in statically with the following exceptions:

        •   The Intel OpenMP* runtime support library is linked in dynamically. To prevent this, specify option -qopenmp-link=static.

        •   The Intel(R) libraries are linked in dynamically when you specify option shared. To prevent this, when you specify shared, you must also specify option static-intel.

    Description:

    This option causes Intel-provided libraries to be linked in statically with certain exceptions (see the Default above). It is the opposite of -shared-intel.

    This option is processed by the that initiates linking, adding library names explicitly to the link command.

    If you specify option -static-intel while option -mcmodel=medium or -mcmodel=large is set, an error will be displayed.

    If you specify option -static-intel and any of the Intel-provided libraries have no static version, a diagnostic will be displayed.

    NOTE: This option only applies to host compilation. When offloading is enabled, it does not impact device-specific compilation.

    Alternate Options:

    None

-static-libgcc (L*X only)

    Links the GNU libgcc library statically.

    Arguments:

    None

    Default:

    OFF The compiler links the GNU libgcc library dynamically.

    Description:

    This option links the GNU libgcc library statically. It is the opposite of option -shared-libgcc.

    This option is processed by the compiler driver command that initiates linking, adding library names explicitly to the link command.

    This option is useful when you want to override the default behavior, which causes the library to be linked dynamically.

    NOTE: If you want to use traceback, you must also link to the static version of the libgcc library. This library enables printing of backtrace information.

    NOTE: This option only applies to host compilation. When offloading is enabled, it does not impact device-specific compilation.

    Alternate Options:

    None

-static-libstdc++ (L*X only)

    Links the GNU libstdc++ library
        statically.

    Arguments:

    None

    Default:

    OFF The compiler links the GNU libstdc++ library dynamically.

    Description:

    This option links the GNU libstdc++ library statically.

    This option is processed by the compiler driver command that initiates linking, adding library names explicitly to the link command.

    This option is useful when you want to override the default behavior, which causes the library to be linked dynamically.

    NOTE: This option only applies to host compilation. When offloading is enabled, it does not impact device-specific compilation.

    Alternate Options:

    None

-std=val (L*X only)

    Tells the compiler to conform to a
        specific language standard.

    Arguments:

    val Specifies the specific language standard to conform to.

        The following values apply to Linux* -std and Windows* /Qstd:

        c++2b
            Enables support for the Working Draft for ISO C++ 2023 DIS standard.

        c++20
            Enables support for the 2020 ISO C++ DIS standard.

        c++17
            Enables support for the 2017 ISO C++ standard with amendments.

        c++14
            Enables support for the 2014 ISO C++ standard with amendments.

        c++11
            Enables support for the 2011 ISO C++ standard with amendments.

        c++98 and
            c++03 Enables support for the 1998 ISO C++ standard with amendments.

        c2x Enables support for the Working Draft for ISO C2x standard.

        c18 and
            c17 Enables support for the 2017 ISO C standard.

            Support for c17 can also be enabled by value iso9899:2017.

            Support for c18 can also be enabled by value iso9899:2018.

        c11 Enables support for the 2011 ISO C standard.

            Support for this standard can also be enabled by value iso9899:2011.

        c99 Enables support for the 1999 ISO C standard.

            Support for this standard can also be enabled by value iso9899:1999.

        c90 and
            c89 Enables support for the 1990 ISO C standard.

            Support for this standard can also be enabled by value iso9899:1990.

        The following values apply only to Linux -std:

        gnu++2b
            Enables support for the Working Draft for ISO C++ 2023 DIS standard plus GNU extensions.

        gnu++20
            Enables support for the 2020 ISO C++ DIS standard plus GNU extensions.

        gnu++17
            Enables support for the 2017 ISO C++ standard with amendments plus GNU extensions.

        gnu++14
            Enables support for the 2014 ISO C++ standard with amendments plus GNU extensions.

        gnu++11
            Enables support for the 2011 ISO C++ standard with amendments plus GNU extensions.

        gnu++98 and
            gnu++03 Enables support for the 1998 ISO C++ standard with amendments plus GNU extensions.

        gnu2x
            Enables support for the Working Draft for ISO C2x standard plus GNU extensions.

        gnu18 and
            gnu17 Enables support for the 2017 ISO C standard plus GNU extensions.

        gnu11
            Enables support for the 2011 ISO C standard plus GNU extensions.

        gnu99
            Enables support for the 1999 ISO C standard plus GNU extensions.

        gnu90 and
            gnu89 Enables support for the 1990 ISO C standard plus GNU extensions.

    Default:

    Default
        for Linux: c++17 The compiler conforms to the 2017 ISO C++ standard. This is true also for SYCL programs.

    Description:

    This option tells the compiler to conform to a specific language standard.

    Alternate Options:

    None

-strict-ansi (L*X only)

    Tells the compiler to implement strict
        ANSI conformance dialect.

    Arguments:

    None

    Default:

    OFF The compiler conforms to default standards.

    Description:

    This option tells the compiler to implement strict ANSI conformance dialect. On Linux* systems, if you need to be compatible with gcc, use the -ansi option.

    This option sets option fmath-errno, which tells the compiler to assume that the program tests errno after calls to math library functions. This restricts optimization because it causes the compiler to treat most math functions as having side effects.

    NOTE: This option only applies to host compilation. When offloading is enabled, it does not impact device-specific compilation.

    Alternate Options:

    None

--sysroot=dir (L*X only)

    Specifies the root directory where
        headers and libraries are located.

    Arguments:

    dir Specifies the local directory that contains copies of target libraries in the corresponding subdirectories.

    Default:

    Off The compiler uses default settings to search for headers and libraries.

    Description:

    This option specifies the root directory where headers and libraries are located.

    For example, if the headers and libraries are normally located in /usr/include and /usr/lib respectively, --sysroot=/mydir will cause the compiler to search in /mydir/usr/include and /mydir/usr/lib for the headers and libraries.

    This option is provided for compatibility with gcc.

    NOTE: Even though this option is not supported for a Windows-to-Windows native compiler, it is supported for a Windows-host to Linux-target compiler.

    Alternate Options:

    None

-Tfilename (L*X only)

    Tells the linker to read link commands
        from a file.

    Arguments:

    filename
        Is the name of the file.

    Default:

    OFF The linker does not read link commands from a file.

    Description:

    This option tells the linker to read link commands from a file.

    NOTE: This option only applies to host compilation. When offloading is enabled, it does not impact device-specific compilation.

    Alternate Options:

    None

-u  symbol (L*X only)

    Tells the compiler the specified symbol
        is undefined.

    Arguments:

    None

    Default:

    OFF Standard rules are in effect for variables.

    Description:

    This option tells the compiler the specified symbol is undefined.

    Alternate Options:

    None

-Uname (L*X only)

    Undefines any definition currently in
        effect for the specified macro.

    Arguments:

    name
        Is the name of the macro to be undefined.

    Default:

    OFF Macro definitions are in effect until they are undefined.

    Description:

    This option undefines any definition currently in effect for the specified macro. It is equivalent to an #undef preprocessing directive.

    On Windows systems, use the /u option to undefine all previously defined preprocessor values.

    Alternate Options:

    None

-unroll[=n] (L*X only)

    Tells the compiler the maximum number of
        times to unroll loops.

    Arguments:

    n   Is the maximum number of times a loop can be unrolled. To disable loop enrolling, specify 0.

    Default:

    -unroll
        The compiler uses default heuristics when unrolling loops.

    Description:

    This option tells the compiler the maximum number of times to unroll loops.

    If you do not specify n, the optimizer determines how many times loops can be unrolled.

    Alternate Options:

    Linux: -funroll-loops

-use-intel-optimized-headers (L*X only)

    Determines whether the performance
        headers directory is added to the include path search list.

    Arguments:

    None

    Default:

    -no-use-intel-optimized-headers
        The performance headers directory is not added to the include path search list.

    Description:

    This option determines whether the performance headers directory is added to the include path search list.

    The performance headers directory is added if you specify [Q]use-intel-optimized-headers. Appropriate libraries are also linked in, as needed, for proper functionality.

    Product and Performance Information

    = = = = = = = = = =

    Performance varies by use, configuration and other factors. Learn more at
        www.Intel.com/PerformanceIndex.

    Notice revision #20201201

    = = = = = = = = = =

    Alternate Options:

    None

-use-msasm (L*X only)

    Enables the use of blocks and entire
        functions of assembly code within a C or C++ file.

    Arguments:

    None

    Default:

    OFF The compiler allows a GNU*-style inline assembly format.

    Description:

    This option enables the use of blocks and entire functions of assembly code within a C or C++ file.

    It allows a Microsoft* MASM-style inline assembly block not a GNU*-style inline assembly block.

    Alternate Options:

    -fasm-blocks

-v [filename] (L*X only)

    Specifies that driver tool commands
        should be displayed and executed.

    Arguments:

    filename
        Is the name of a source file to be compiled. A space must appear before the file name.

    Default:

    OFF No tool commands are shown.

    Description:

    This option specifies that driver tool commands should be displayed and executed.

    If you use this option without specifying a source file name, the compiler displays only the version of the compiler.

    Alternate Options:

    None

-vec (L*X only)

-no-vec (L*X only)

    Enables or disables vectorization.

    Arguments:

    None

    Default:

    -vec
        Vectorization is enabled if option O2 or higher is in effect.

    Description:

    This option enables or disables vectorization.

    To disable vectorization, specify -no-vec (Linux*) or /Qvec- (Windows*).

    NOTE: Using this option enables vectorization at default optimization levels for both Intel(R) microprocessors and non-Intel microprocessors. Vectorization may call library routines that can result in additional performance gain on Intel microprocessors than on non-Intel microprocessors.

    NOTE: This option only applies to host compilation. When offloading is enabled, it does not impact device-specific compilation.

    Alternate Options:

    None

-vec-threshold[n] (L*X only)

    Sets a threshold for the vectorization of
        loops.

    Arguments:

    n   Is an integer whose value is the threshold for the vectorization of loops. Possible values are 0 through 100.

        If n is 0, loops get vectorized always, regardless of computation work volume.

        If n is 100, loops get vectorized when performance gains are predicted based on the compiler analysis data. Loops get vectorized only if profitable vector-level parallel execution is almost certain.

        The intermediate 1 to 99 values represent the percentage probability for profitable speed-up. For example, n=50 directs the compiler to vectorize only if there is a 50% probability of the code speeding up if executed in vector form.

    Default:

    -vec-threshold100
        Loops get vectorized only if profitable vector-level parallel execution is almost certain. This is also the default if you do not specify n.

    Description:

    This option sets a threshold for the vectorization of loops based on the probability of profitable execution of the vectorized loop in parallel.

    This option is useful for loops whose computation work volume cannot be determined at compile-time. The threshold is usually relevant when the loop trip count is unknown at compile-time.

    The compiler applies a heuristic that tries to balance the overhead of creating multiple threads versus the amount of work available to be shared amongst the threads.

    NOTE: This option only applies to host compilation. When offloading is enabled, it does not impact device-specific compilation.

    Alternate Options:

    None

--version (L*X only)

    Tells the compiler to display GCC-style
        version information.

    Arguments:

    None

    Default:

    OFF

    Description:

    Tells the compiler to display GCC-style version information.

    NOTE: This option only applies to host compilation. When offloading is enabled, it does not impact device-specific compilation.

    Alternate Options:

    None

-w (L*X only)

    Disables all warning messages.

    Arguments:

    None

    Default:

    OFF Default warning messages are enabled.

    Description:

    This option disables all warning messages.

    Alternate Options:

    Linux: -w0

    Windows: /W0

-wn (L*X only)

    Specifies the level of diagnostic
        messages to be generated by the compiler.

    Arguments:

    n   Is the level of diagnostic messages to be generated. Possible values are:

        0   Enables diagnostics for errors. Disables diagnostics for warnings.

        1   Enables diagnostics for warnings and errors.

        2   Enables diagnostics for warnings and errors. On Linux* systems, additional warnings are enabled. On Windows* systems, this setting is equivalent to level 1 (n = 1).

        3   Enables diagnostics for remarks, warnings, and errors. Additional warnings are also enabled above level 2 (n = 2). This level is recommended for production purposes.

        4   Enables diagnostics for all level 3 (n = 3) warnings plus informational warnings and remarks, which in most cases can be safely ignored. This value is only available on Windows* systems.

        5   Enables diagnostics for all remarks, warnings, and errors. This setting produces the most diagnostic messages. This value is only available on Windows* systems.

    Default:

    n=1 The compiler displays diagnostics for warnings and errors.

    Description:

    This option specifies the level of diagnostic messages to be generated by the compiler.

    On Windows systems, option /W4 is equivalent to option /Wall.

    The -wn, /Wn, and Wall options can override each other. The last option specified on the command line takes precedence.

    Alternate Options:

    None

-Wa,option1[,option2,...] (L*X only)

    Passes options to the assembler for
        processing.

    Arguments:

    option
        Is an assembler option. This option is not processed by the driver and is directly passed to the assembler.

    Default:

    OFF No options are passed to the assembler.

    Description:

    This option passes one or more options to the assembler for processing. If the assembler is not invoked, these options are ignored.

    NOTE: This option only applies to host compilation. When offloading is enabled, it does not impact device-specific compilation.

    Alternate Options:

    None

-Wabi (L*X only)

-Wno-abi (L*X only)

    Determines whether a warning is issued if
        generated code is not C++ ABI compliant.

    Arguments:

    None

    Default:

    -Wno-abi
        No warning is issued when generated code is not C++ ABI compliant.

    Description:

    This option determines whether a warning is issued if generated code is not C++ ABI compliant.

    Alternate Options:

    None

-Wall (L*X only)

    Enables warning and error diagnostics.

    Arguments:

    None

    Default:

    OFF Only default warning diagnostics are enabled.

    Description:

    This option enables many warning and error diagnostics.

    On Windows* systems, this option is equivalent to the /W4 option. It enables diagnostics for all level 3 warnings plus informational warnings and remarks.

    However, on Linux* systems, this option is similar to gcc option -Wall. It displays all errors and some of the warnings that are typically reported by gcc option -Wall. If you want to display all warnings, specify the -w2 or -w3 option.

    The Wall, -wn, and /Wn options can override each other. The last option specified on the command line takes precedence.

    Alternate Options:

    None

-watch[=keyword[,
    keyword...]] (L*X only)

-nowatch (L*X only)

    Tells the compiler to display certain
        information to the console output window.

    Arguments:

    keyword
        Determines what information is displayed. Possible values are:

        none
            Disables cmd and source.

        [no]cmd
            Determines whether driver tool commands are displayed and executed.

        [no]source
            Determines whether the name of the file being compiled is displayed.

        all Enables cmd and source.

    Default:

    nowatch
        Pass information and source file names are not displayed to the console output window.

    Description:

    Tells the compiler to display processing information (pass information and source file names) to the console output window.

    Option
        watch keyword Description

    none
        Tells the compiler to not display pass information and source file names to the console output window. This is the same as specifying nowatch.

    cmd Tells the compiler to display and execute driver tool commands.

    source
        Tells the compiler to display the name of the file being compiled.

    all Tells the compiler to display pass information and source file names to the console output window. This is the same as specifying watch with no keyword. For heterogeneous compilation, the tool commands for the host and the offload compilations will be displayed.

    NOTE: This option only applies to host compilation. When offloading is enabled, it does not impact device-specific compilation.

    Alternate Options:

    watch cmd
        Linux: -v

-Wcheck-unicode-security (L*X only)

-Wno-check-unicode-security (L*X only)

    Determines whether the compiler performs
        source code checking for Unicode vulnerabilities.

    Arguments:

    None

    Default:

    Wno-check-unicode-security
        The compiler does not perform source code checking for Unicode vulnerabilities.

    Description:

    This option determines whether the compiler performs source code checking for Unicode vulnerabilities.

    Option Wcheck-unicode-security enables Unicode checking. The compiler will detect and warn about Unicode constructs that can be exploited by using bi-directional formatting codes, zero-width characters in strings, and use of zero-width characters and homoglyphs in identifiers.

    Option Wno-check-unicode-security disables Unicode checking.

    NOTE: This option only applies to host compilation. When offloading is enabled, it does not impact device-specific compilation.

    Alternate Options:

    None

-Wcomment (L*X only)

-Wno-comment (L*X only)

    Determines whether a warning is issued
        when /* appears in the middle of a /* */ comment.

    Arguments:

    None

    Default:

    -Wno-comment
        No warning is issued when /* appears in the middle of a /* */ comment.

    Description:

    This option determines whether a warning is issued when /* appears in the middle of a /* */ comment.

    Alternate Options:

    None

-Wdeprecated (L*X only)

-Wno-deprecated (L*X only)

    Determines whether warnings are issued
        for deprecated C++ headers.

    Arguments:

    None

    Default:

    -Wdeprecated
        The compiler issues warnings for deprecated C++ headers.

    Description:

    This option determines whether warnings are issued for deprecated C++ headers. It has no effect in C compilation mode.

    Option -Wdeprecated enables these warnings by defining the __DEPRECATED macro for preprocessor.

    To disable warnings for deprecated C++ headers, specify -Wno-deprecated.

    Alternate Options:

    None

-Weffc++ (L*X only)

    Enables warnings based on certain C++
        programming guidelines.

    Arguments:

    None

    Default:

    OFF Diagnostics are not enabled.

    Description:

    This option enables warnings based on certain programming guidelines developed by Scott Meyers in his books on effective C++ programming. With this option, the compiler emits warnings for these guidelines:

    •   Use const and inline rather than #define. Note that you will only get this in user code, not system header code.

    •   Use <iostream> rather than <stdio.h>.

    •   Use new and delete rather than malloc and free.

    •   Use C++ style comments in preference to C style comments. C comments in system headers are not diagnosed.

    •   Use delete on pointer members in destructors. The compiler diagnoses any pointer that does not have a delete.

    •   Make sure you have a user copy constructor and assignment operator in classes containing pointers.

    •   Use initialization rather than assignment to members in constructors.

    •   Make sure the initialization list ordering matches the declartion list ordering in constructors.

    •   Make sure base classes have virtual destructors.

    •   Make sure operator= returns *this.

    •   Make sure prefix forms of increment and decrement return a const object.

    •   Never overload operators &&, ||, and ,.

    NOTE: The warnings generated by this compiler option are based on the following books from Scott Meyers:

    •   Effective C++ Second Edition - 50 Specific Ways to Improve Your Programs and Designs

    •   More Effective C++ - 35 New Ways to Improve Your Programs and Designs

    Alternate Options:

    None

-Werror (L*X only)

    Changes all warnings to errors.

    Arguments:

    None

    Default:

    OFF The compiler returns diagnostics as usual.

    Description:

    This option changes all warnings to errors.

    Alternate Options:

    None

-Werror-all (L*X only)

    Causes all warnings and currently enabled
        remarks to be reported as errors.

    Arguments:

    None

    Default:

    OFF The compiler returns diagnostics as usual.

    Description:

    This option causes all warnings and currently enabled remarks to be reported as errors.

    Alternate Options:

    None

-Wextra-tokens (L*X only)

-Wno-extra-tokens (L*X only)

    Determines whether warnings are issued
        about extra tokens at the end of preprocessor directives.

    Arguments:

    None

    Default:

    -Wno-extra-tokens
        The compiler does not warn about extra tokens at the end of preprocessor directives.

    Description:

    This option determines whether warnings are issued about extra tokens at the end of preprocessor directives.

    Alternate Options:

    None

-Wformat (L*X only)

-Wno-format (L*X only)

    Determines whether argument checking is
        enabled for calls to printf, scanf, and so forth.

    Arguments:

    None

    Default:

    -Wno-format
        Argument checking is not enabled for calls to printf, scanf, and so forth.

    Description:

    This option determines whether argument checking is enabled for calls to printf, scanf, and so forth.

    Alternate Options:

    None

-Wformat-security (L*X only)

-Wno-format-security (L*X only)

    Determines whether the compiler issues a
        warning when the use of format functions may cause security problems.

    Arguments:

    None

    Default:

    -Wno-format-security
        No warning is issued when the use of format functions may cause security problems.

    Description:

    This option determines whether the compiler issues a warning when the use of format functions may cause security problems.

    When -Wformat-security is specified, it warns about uses of format functions where the format string is not a string literal and there are no format arguments.

    Alternate Options:

    None

-Wmain (L*X only)

-Wno-main (L*X only)

    Determines whether a warning is issued if
        the return type of main is not expected.

    Arguments:

    None

    Default:

    -Wno-main
        No warning is issued if the return type of main is not expected.

    Description:

    This option determines whether a warning is issued if the return type of main is not expected.

    Alternate Options:

    None

-Wmissing-declarations (L*X only)

-Wno-missing-declarations (L*X only)

    Determines whether warnings are issued
        for global functions and variables without prior declaration.

    Arguments:

    None

    Default:

    -Wno-missing-declarations
        No warnings are issued for global functions and variables without prior declaration.

    Description:

    This option determines whether warnings are issued for global functions and variables without prior declaration.

    Alternate Options:

    None

-Wmissing-prototypes (L*X only)

-Wno-missing-prototypes (L*X only)

    Determines whether warnings are issued
        for missing prototypes.

    Arguments:

    None

    Default:

    -Wno-missing-prototypes
        No warnings are issued for missing prototypes.

    Description:

    Determines whether warnings are issued for missing prototypes.

    If -Wmissing-prototypes is specified, it tells the compiler to detect global functions that are defined without a previous prototype declaration.

    Alternate Options:

    None

-Wnon-virtual-dtor

    Tells the compiler to issue a warning
        when a class appears to be polymorphic, yet it declares a non-virtual one.

    Arguments:

    None

    Default:

    OFF The compiler does not issue a warning.

    Description:

    Tells the compiler to issue a warning when a class appears to be polymorphic, yet it declares a non-virtual one. This option is supported in C++ only.

    Alternate Options:

    None

-Wno-sycl-strict (L*X only)

    Disables warnings that enforce strict
        SYCL* language compatibility.

    Arguments:

    None

    Default:

    OFF Warnings that enforce strict SYCL* language compatibility are enabled.

    Description:

    This option disables warnings that enforce strict SYCL* language compatibility.

    Alternate Options:

    None

-Wp,option1[,option2,...] (L*X only)

    Passes options to the preprocessor.

    Arguments:

    option
        Is a preprocessor option. This option is not processed by the driver and is directly passed to the preprocessor.

    Default:

    OFF No options are passed to the preprocessor.

    Description:

    This option passes one or more options to the preprocessor. If the preprocessor is not invoked, these options are ignored.

    This option is equivalent to specifying option -Qoption,cpp, options.

    NOTE: This option only applies to host compilation. When offloading is enabled, it does not impact device-specific compilation.

    Alternate Options:

    None

-Wpointer-arith (L*X only)

-Wno-pointer-arith (L*X only)

    Determines whether warnings are issued
        for questionable pointer arithmetic.

    Arguments:

    None

    Default:

    -Wno-pointer-arith
        No warnings are issued for questionable pointer arithmetic.

    Description:

    Determines whether warnings are issued for questionable pointer arithmetic.

    Alternate Options:

    None

-Wreorder (L*X only)

    Tells the compiler to issue a warning
        when the order of member initializers does not match the order in which they must be executed.

    Arguments:

    None

    Default:

    OFF The compiler does not issue a warning.

    Description:

    This option tells the compiler to issue a warning when the order of member initializers does not match the order in which they must be executed. This option is supported for C++ only.

    Alternate Options:

    None

-Wreturn-type (L*X only)

-Wno-return-type (L*X only)

    Determines whether warnings are issued
        when a function is declared without a return type, when the definition of a function returning void contains a return statement with an expression, or when the closing brace of a function returning non-void is reached.

    Arguments:

    None

    Default:

    ON for one condition
        A warning is issued when the closing brace of a function returning non-void is reached.

    Description:

    This option determines whether warnings are issued for the following:

    •   When a function is declared without a return type

    •   When the definition of a function returning void contains a return statement with an expression

    •   When the closing brace of a function returning non-void is reached

    Specify -Wno-return-type if you do not want to see warnings about the above diagnostics.

    Alternate Options:

    None

-Wshadow (L*X only)

-Wno-shadow (L*X only)

    Determines whether a warning is issued
        when a variable declaration hides a previous declaration.

    Arguments:

    None

    Default:

    -Wno-shadow
        No warning is issued when a variable declaration hides a previous declaration.

    Description:

    This option determines whether a warning is issued when a variable declaration hides a previous declaration. Same as -ww1599.

    Alternate Options:

    None

-Wsign-compare (L*X only)

-Wno-sign-compare (L*X only)

    Determines whether warnings are issued
        when a comparison between signed and unsigned values could produce an incorrect result when the signed value is converted to unsigned.

    Arguments:

    None

    Default:

    -Wno-sign-compare
        The compiler does not issue these warnings

    Description:

    This option determines whether warnings are issued when a comparison between signed and unsigned values could produce an incorrect result when the signed value is converted to unsigned.

    On Linux* systems, this option is provided for compatibility with gcc.

    Alternate Options:

    None

-Wstrict-aliasing (L*X only)

-Wno-strict-aliasing (L*X only)

    Determines whether warnings are issued
        for code that might violate the optimizer's strict aliasing rules.

    Arguments:

    None

    Default:

    -Wno-strict-aliasing
        No warnings are issued for code that might violate the optimizer's strict aliasing rules.

    Description:

    This option determines whether warnings are issued for code that might violate the optimizer's strict aliasing rules. These warnings will only be issued if you also specify option -fstrict-aliasing.

    Alternate Options:

    None

-Wstrict-prototypes (L*X only)

-Wno-strict-prototypes (L*X only)

    Determines whether warnings are issued
        for functions declared or defined without specified argument types.

    Arguments:

    None

    Default:

    -Wno-strict-prototypes
        No warnings are issued for functions declared or defined without specified argument types.

    Description:

    This option determines whether warnings are issued for functions declared or defined without specified argument types.

    Alternate Options:

    None

-Wtrigraphs (L*X only)

-Wno-trigraphs (L*X only)

    Determines whether warnings are issued if
        any trigraphs are encountered that might change the meaning of the program.

    Arguments:

    None

    Default:

    -Wno-trigraphs
        No warnings are issued if any trigraphs are encountered that might change the meaning of the program.

    Description:

    This option determines whether warnings are issued if any trigraphs are encountered that might change the meaning of the program.

    Alternate Options:

    None

-Wuninitialized (L*X only)

-Wno-uninitialized (L*X only)

    Determines whether a warning is issued if
        a variable is used before being initialized.

    Arguments:

    None

    Default:

    -Wno-uninitialized
        No warning is issued if a variable is used before being initialized.

    Description:

    This option determines whether a warning is issued if a variable is used before being initialized. Equivalent to -ww592 and -wd592.

    Alternate Options:

    -ww592 and -wd592

-Wunknown-pragmas (L*X only)

-Wno-unknown-pragmas (L*X only)

    Determines whether a warning is issued if
        an unknown #pragma directive is used.

    Arguments:

    None

    Default:

    -Wunknown-pragmas
        A warning is issued if an unknown #pragma directive is used.

    Description:

    This option determines whether a warning is issued if an unknown #pragma directive is used.

    Alternate Options:

    None

-Wunused-function (L*X only)

-Wno-unused-function (L*X only)

    Determines whether a warning is issued if
        a declared function is not used.

    Arguments:

    None

    Default:

    -Wno-unused-function
        No warning is issued if a declared function is not used.

    Description:

    This option determines whether a warning is issued if a declared function is not used.

    Alternate Options:

    None

-Wunused-variable (L*X only)

-Wno-unused-variable (L*X only)

    Determines whether a warning is issued if
        a local or non-constant static variable is unused after being declared.

    Arguments:

    None

    Default:

    -Wno-unused-variable
        No warning is issued if a local or non-constant static variable is unused after being declared.

    Description:

    This option determines whether a warning is issued if a local or non-constant static variable is unused after being declared.

    Alternate Options:

    None

-Wwrite-strings (L*X only)

    Issues a diagnostic message if const char
        * is converted to (non-const) char *.

    Arguments:

    None

    Default:

    OFF No diagnostic message is issued if const char * is converted to (non-const) char*.

    Description:

    This option issues a diagnostic message if const char* is converted to (non-const) char *.

    Alternate Options:

    None

-x  type (L*X only)

    All source files found subsequent to -x
        type will be recognized as a particular type.

    Arguments:

    type
        is the type of source file. Possible values are:

        c++ C++ source file

        c++-header
            C++ header file

        c++-cpp-output
            C++ pre-processed file

        c   C source file

        c-header
            C header file

        cpp-output
            C pre-processed file

        assembler
            Assembly file

        assembler-with-cpp
            Assembly file that needs to be preprocessed

        none
            Disable recognition, and revert to file extension

    Default:

    none
        Disable recognition and revert to file extension.

    Description:

    All source files found subsequent to -xtype will be recognized as a particular type.

    Alternate Options:

    None

-xcode (L*X only)

    Tells the compiler which processor
        features it may target, including which instruction sets and optimizations it may generate.

    Arguments:

    code
        Specifies a feature set that the compiler can target, including which instruction sets and optimizations it may generate. Possible values are:

        ALDERLAKE AMBERLAKE BROADWELL CANNONLAKE CASCADELAKE COFFEELAKE COOPERLAKE GOLDMONT
            GOLDMONT-PLUS HASWELL ICELAKE-CLIENT (or ICELAKE) ICELAKE-SERVER IVYBRIDGE KABYLAKE ROCKETLAKE SANDYBRIDGE SAPPHIRERAPIDS SILVERMONT SKYLAKE SKYLAKE-AVX512 TIGERLAKE TREMONT WHISKEYLAKE May generate instructions for processors that support the specified Intel(R) processor or microarchitecture code name. Optimizes for the specified Intel(R) processor or microarchitecture code name.

            Keyword ICELAKE is deprecated and may be removed in a future release.

        COMMON-AVX512
            May generate Intel(R) Advanced Vector Extensions 512 (Intel(R) AVX-512) Foundation instructions, Intel(R) AVX-512 Conflict Detection Instructions (CDI), as well as the instructions enabled with CORE-AVX2. Optimizes for Intel(R) processors that support Intel(R) AVX-512 instructions.

        CORE-AVX512
            May generate Intel(R) Advanced Vector Extensions 512 (Intel(R) AVX-512) Foundation instructions, Intel(R) AVX-512 Conflict Detection Instructions (CDI), Intel(R) AVX-512 Doubleword and Quadword Instructions (DQI), Intel(R) AVX-512 Byte and Word Instructions (BWI) and Intel(R) AVX-512 Vector Length Extensions (VLE), as well as the instructions enabled with CORE-AVX2. Optimizes for Intel(R) processors that support Intel(R) AVX-512 instructions.

        CORE-AVX2
            May generate Intel(R) Advanced Vector Extensions 2 (Intel(R) AVX2), Intel(R) AVX, SSE4.2, SSE4.1, SSE3, SSE2, SSE, and SSSE3 instructions for Intel(R) processors. Optimizes for Intel(R) processors that support Intel(R) AVX2 instructions.

        CORE-AVX-I
            May generate Float-16 conversion instructions and the RDRND instruction, Intel(R) Advanced Vector Extensions (Intel(R) AVX), Intel(R) SSE4.2, SSE4.1, SSE3, SSE2, SSE, and SSSE3 instructions for Intel(R) processors. Optimizes for Intel(R) processors that support Float-16 conversion instructions and the RDRND instruction.

        AVX May generate Intel(R) Advanced Vector Extensions (Intel(R) AVX), Intel(R) SSE4.2, SSE4.1, SSE3, SSE2, SSE, and SSSE3 instructions for Intel(R) processors. Optimizes for Intel processors that support Intel(R) AVX instructions.

        SSE4.2
            May generate Intel(R) SSE4 Efficient Accelerated String and Text Processing instructions, Intel(R) SSE4 Vectorizing Compiler and Media Accelerator, and Intel(R) SSE3, SSE2, SSE, and SSSE3 instructions for Intel(R) processors. Optimizes for Intel processors that support Intel(R) SSE4.2 instructions.

        SSE4.1
            May generate Intel(R) SSE4 Vectorizing Compiler and Media Accelerator instructions for Intel(R) processors. May generate Intel(R) SSE4.1, SSE3, SSE2, SSE, and SSSE3 instructions for Intel processors that support Intel(R) SSE4.1 instructions.

        ATOM_SSE4.2
            May generate MOVBE instructions for Intel(R) processors, depending on the setting of option -minstruction (Linux) or /Qinstruction (Windows). May also generate Intel(R) SSE4.2, SSE3, SSE2, and SSE instructions for Intel processors. Optimizes for Intel Atom(R) processors that support Intel(R) SSE4.2 and MOVBE instructions.

        ATOM_SSSE3
            May generate MOVBE instructions for Intel(R) processors, depending on the setting of option -minstruction (Linux) or /Qinstruction (Windows). May also generate SSSE3, Intel(R) SSE3, SSE2, and SSE instructions for Intel processors. Optimizes for Intel Atom(R) processors that support Intel(R) SSE3 and MOVBE instructions.

        SSSE3
            May generate SSSE3 and Intel(R) SSE3, SSE2, and SSE instructions for Intel(R) processors. Optimizes for Intel processors that support SSSE3 instructions.

        SSE3
            May generate Intel(R) SSE3, SSE2, and SSE instructions for Intel(R) processors. Optimizes for Intel processors that support Intel(R) SSE3 instructions.

    Default:

    OFF If option -x or -march is not specified (Linux), the default target architecture supports Intel(R) SSE2 instructions.

    Description:

    This option tells the compiler which processor features it may target, including which instruction sets and optimizations it may generate.

    The resulting executables created from these option code values can only be run on Intel(R) processors that support the indicated instruction set.

    Do not use code values to create binaries that will execute on a processor that is not compatible with the targeted processor. The resulting program may fail with an illegal instruction exception or display other unexpected behavior.

    Compiling the function main() with any of the code values produces binaries that display a fatal runtime error if they are executed on unsupported processors, including all non-Intel processors.

    Compiler options -march (Linux) and /arch (Windows) produce binaries that can be run on processors not made by Intel that implement the same capabilities as the corresponding Intel(R) processors.

    The -x and /Qx options enable additional optimizations not enabled with options -march or /arch.

    Linux

    Options -x and -march are mutually exclusive. If both are specified, the compiler uses the last one specified and generates a warning.

    Windows

    Options /Qx and /arch are mutually exclusive. If both are specified, the compiler uses the last one specified and generates a warning.

    NOTE: All settings do a CPU check. However, if you specify option -O0 (Linux) or option /Od (Windows), no CPU check is performed.

    NOTE: This option only applies to host compilation. When offloading is enabled, it does not impact device-specific compilation.

    Product and Performance Information

    = = = = = = = = = =

    Performance varies by use, configuration and other factors. Learn more at
        www.Intel.com/PerformanceIndex.

    Notice revision #20201201

    = = = = = = = = = =

    Alternate Options:

    None

-X (L*X only)

    Removes standard directories from the
        include file search path.

    Arguments:

    None

    Default:

    OFF Standard directories are in the include file search path.

    Description:

    This option removes standard directories from the include file search path. It prevents the compiler from searching the default path specified by the INCLUDE environment variable.

    On Linux* systems, specifying -X (or -noinclude) prevents the compiler from searching in /usr/include for files specified in an INCLUDE statement.

    You can use this option with the I option to prevent the compiler from searching the default path for include files and direct it to use an alternate path.

    Alternate Options:

    Linux: -nostdinc

-xHost (L*X only)

    Tells the compiler to generate
        instructions for the highest instruction set available on the compilation host processor.

    Arguments:

    None

    Default:

    OFF If option -x or -march is not specified (Linux), the default target architecture supports Intel(R) SSE2 instructions.

    Description:

    This option tells the compiler to generate instructions for the highest instruction set available on the compilation host processor.

    The instructions generated by this compiler option differ depending on the compilation host processor.

    For more information on other settings for option [Q]x, see that option description.

    NOTE: This option only applies to host compilation. When offloading is enabled, it does not impact device-specific compilation.

    Product and Performance Information

    = = = = = = = = = =

    Performance varies by use, configuration and other factors. Learn more at
        www.Intel.com/PerformanceIndex.

    Notice revision #20201201

    = = = = = = = = = =

    Alternate Options:

    None

-Xlinker
    option (L*X only)

    Passes a linker option directly to the
        linker.

    Arguments:

    option
        Is a linker option.

    Default:

    OFF No options are passed directly to the linker.

    Description:

    This option passes a linker option directly to the linker. If -Xlinker -shared is specified, only -shared is passed to the linker and no special work is done to ensure proper linkage for generating a shared object. -Xlinker just takes whatever arguments are supplied and passes them directly to the linker.

    If you want to pass compound options to the linker, for example "-L $HOME/lib", you must use the following method:

    -Xlinker -L -Xlinker $HOME/lib

    NOTE: This option only applies to host compilation. When offloading is enabled, it does not impact device-specific compilation.

    Alternate Options:

    None

-Xs -option or
    -Xsoption (L*X only)

    Passes options to the backend tool.

    Arguments:

    option
        Is the option that you want to pass to the backend tool in device compilation.

        To see the values you can use for option, specify compiler option -fsycl-help to display the help information for the offline tools.

    Default:

    OFF No options are passed to the backend tool.

    Description:

    This option passes options to the backend tool. It is a shortcut for option Xsycl-target-backend.

    For example, the following option (using syntax form -Xsoption):

    -Xsversion

    and the following option (using syntax form -Xs-option):

    -Xs -version

    are both equivalent to specifying:

    -Xsycl-target-backend -version

    NOTE: When using Ahead of Time (AOT) compilation, the options passed with -Xs are not compiler options.

    To see a list of the options you can pass with -Xs when using AOT, specify -fsycl-help=gen, -fsycl-help=x86_64, or -fsycl-help=fpga on the command line.

    NOTE: When offloading is enabled, this option only applies to device-specific compilation.

    Alternate Options:

    None

-Xopenmp-target-tool=T
    "options" (L*X only)

    Enables options to be passed to the
        specified tool in the device compilation tool chain for the target.

    Arguments:

    tool
        Can be one of the following:

        frontend
            Indicates the frontend + middle end of the Standard Portable Intermediate Representation (SPIR-V*)-based device compiler for target triple T.

            The middle end is the part of a SPIR-V*-based device compiler that generates SPIR-V*. This SPIR-V* is then passed by the compiler driver to the backend of target T.

        backend
            Indicates Ahead of Time (AOT) compilation for target triple T and Just in Time (JIT) compilation for target T at runtime.

        linker
            Indicates the device code linker for target triple T.

        Some targets may have frontend and backend in one component; in that case, options are merged.

    T   Is the target triple device.

    options
        Are the options you want to pass to tool.

    Default:

    OFF No options are passed to a tool.

    Description:

    This option enables options to be passed to the specified tool in the device compilation tool chain for the target.

    NOTE: When OpenMP* offloading is enabled, this option only applies to device-specific compilation.

    Alternate Options:

    None

-Xsycl-target-tool=T
    "options" (L*X only)

    Enables options to be passed to the
        specified tool in the device compilation tool chain for the target.

    Arguments:

    tool
        Can be one of the following:

        frontend
            Indicates the frontend + middle end of the Standard Portable Intermediate Representation (SPIR-V*)-based device compiler for target triple T.

            The middle end is the part of a SPIR-V*-based device compiler that generates SPIR-V*. This SPIR-V* is then passed by the compiler driver to the backend of target T.

        backend
            Indicates Ahead of Time (AOT) compilation for target triple T and Just in Time (JIT) compilation for target T at runtime.

        linker
            Indicates the device code linker for target triple T.

        Some targets may have frontend and backend in one component; in that case, options are merged.

    T   Is the target triple device.

    options
        Are the options you want to pass to tool.

    Default:

    OFF No options are passed to a tool.

    Description:

    This option enables options to be passed to the specified tool in the device compilation tool chain for the target.

    NOTE: When SYCL offloading is enabled, this option only applies to device-specific compilation.

    Alternate Options:

    None.

-Zp[n] (L*X only)

    Specifies alignment for structures on
        byte boundaries.

    Arguments:

    n   Is the byte size boundary. Possible values are 1, 2, 4, 8, or 16.

    Default:

    Zp16
        Structures are aligned on either size boundary 16 or the boundary that will naturally align them.

    Description:

    This option specifies alignment for structures on byte boundaries.

    If you do not specify n, you get Zp16.

    Alternate Options:

    None

PREDEFINED MACROS

To see supported predefined macros, specify the following command:

dpcpp -x c /dev/null -dM -E

This will output the currently defined macros.

Supported Environment Variables

You can customize your system environment by specifying paths where the compiler searches for certain files such as libraries, include files, configuration files, and certain settings.

  Compiler Compile-Time Environment Variables

The following table shows the compile-time environment variables that affect the compiler:

Compile-Time Environment Variable
    Description

Specifies the configuration file for customizing compilations when invoking the compiler using

Specifies the configuration file for customizing compilations when invoking the compiler using

__INTEL_PRE_CFLAGS

__INTEL_POST_CFLAGS
    Specifies a set of compiler options to add to the compile line.

This is an extension to the facility already provided in the compiler configuration file
    icx.cfg.

NOTE: By default, a configuration file named icx.cfg (Windows, Linux), or icpx.cfg (Linux) is used. This file is in the same directory as the compiler executable. To use another configuration file in another location, you can use the ICXCFG (Windows, Linux), ICPXCFG (Linux) environment variable to assign the directory and file name for the configuration file.

You can insert command line options in the prefix position using
    __INTEL_PRE_CFLAGS , or in the suffix position using __INTEL_POST_CFLAGS. The command line is built as follows:

Syntax:icx<PRE flags>
    <flags from configuration file> <flags from the compiler invocation> <POST flags>

NOTE: The driver issues a warning that the compiler is overriding an option because of an environment variable, but only when you include the option /W5 (Windows) or -w3 (Linux).

PATH
    Specifies the directories the system searches for binary executable files.

NOTE: On Windows, this also affects the search for Dynamic Link Libraries (DLLs).

TMP

TMPDIR

TEMP
    Specifies the location for temporary files. If none of these are specified, or writeable, or found, the compiler stores temporary files in /tmp (Linux) or the current directory (Windows).

The compiler searches for these variables in the following order:
    TMP, TMPDIR, and TEMP.

LD_LIBRARY_PATH (Linux)
    Specifies the location for shared objects (.so files).

LIB (Windows)
    Specifies the directories for all libraries used by the compiler and linker.

GNU Environment Variables and Extensions

CPATH (Linux)
    Specifies the path to include directory for C/C++ compilations.

C_INCLUDE_PATH (Linux)
    Specifies path to include directory for C compilations.

CPLUS_INCLUDE_PATH (Linux)
    Specifies path to include directory for C++ compilations.

DEPENDENCIES_OUTPUT (Linux)
    Specifies how to output dependencies for make based on the non-system header files processed by the compiler. System header files are ignored in the dependency output.

GCC_EXEC_PREFIX (Linux)
    Specifies alternative names for the linker (.B ld ) and assembler (.B as ).

LIBRARY_PATH (Linux)
    Specifies the path for libraries to be used during the link phase.

SUNPRO_DEPENDENCIES (Linux)
    This variable is the same as DEPENDENCIES_OUTPUT, except that system header files are not ignored.

NOTE: INTEL_ROOT is an environment variable that is reserved for the Intel(R) Compiler. Its use is not supported.

  Compiler Runtime Environment Variables

The following table summarizes compiler environment variables that are recognized at runtime.

Runtime Environment Variable
    Description

GNU extensions (recognized by the Intel OpenMP* compatibility library)

GOMP_CPU_AFFINITY (Linux)
    GNU extension recognized by the Intel OpenMP compatibility library. Specifies a list of OS processor IDs.

You must set this environment variable before the first parallel region or before certain API calls including
    omp_get_max_threads(), omp_get_num_procs() and any affinity API calls. For detailed information on this environment variable, see Thread Affinity Interface.

Default: Affinity is disabled

GOMP_STACKSIZE (Linux)
    GNU extension recognized by the Intel OpenMP compatibility library. Same as OMP_STACKSIZE.KMP_STACKSIZE overrides GOMP_STACKSIZE, which overrides OMP_STACKSIZE.

Default: See the description for
    OMP_STACKSIZE.

OpenMP Environment Variables (OMP_) and Extensions (KMP_)

OMP_CANCELLATION
    Activates cancellation of the innermost enclosing region of the type specified. If set to TRUE, the effects of the cancel construct and of cancellation points are enabled and cancellation is activated. If set to FALSE, cancellation is disabled and the cancel construct and cancellation points are effectively ignored.

NOTE: Internal barrier code will work differently depending on whether the cancellation is enabled. Barrier code should repeatedly check the global flag to figure out if the cancellation had been triggered. If a thread observes the cancellation it should leave the barrier prematurely with the return value 1 (may wake up other threads). Otherwise, it should leave the barrier with the return value 0.

Enables (TRUE) or disables (FALSE) cancellation of the innermost enclosing region of the type specified.

Default: FALSE

Example:
    OMP_CANCELLATION=TRUE

OMP_DISPLAY_ENV
    Enables (TRUE) or disables (FALSE) the printing to stderr of the OpenMP version number and the values associated with the OpenMP environment variable.

Possible values are: TRUE, FALSE, or VERBOSE.

Default: FALSE

Example: OMP_DISPLAY_ENV=TRUE

OMP_DEFAULT_DEVICE
    Sets the device that will be used in a target region. The OpenMP routine omp_set_default_device or a device clause in a target pragma can override this variable.

If no device with the specified device number exists, the code is executed on the host. If this environment variable is not set, device number 0 is used.

OMP_DYNAMIC
    Enables (TRUE) or disables (FALSE) the dynamic adjustment of the number of threads.

Default: FALSE

Example: OMP_DYNAMIC=TRUE

OMP_MAX_ACTIVE_LEVELS
    The maximum number of levels of parallel nesting for the program.

Possible values: Non-negative integer.

Default: 1

OMP_NESTED
    Deprecated; use OMP_MAX_ACTIVE_LEVELS instead.

OMP_NUM_THREADS
    Sets the maximum number of threads to use for OpenMP parallel regions if no other value is specified in the application.

The value can be a single integer, in which case it specifies the number of threads for all parallel regions. The value can also be a comma-separated list of integers, in which case each integer specifies the number of threads for a parallel region at a nesting level.

The first position in the list represents the outer-most parallel nesting level, the second position represents the next-inner parallel nesting level, and so on. At any level, the integer can be left out of the list. If the first integer in a list is left out, it implies the normal default value for threads is used at the outer-most level. If the integer is left out of any other level, the number of threads for that level is inherited from the previous level.

This environment variable applies to the options
    Qopenmp (Windows) or qopenmp (Linux).

Default: The number of processors visible to the operating system on which the program is executed.

Syntax: OMP_NUM_THREADS=value[,value]*

OMP_PLACES
    Specifies an explicit ordered list of places, either as an abstract name describing a set of places or as an explicit list of places described by nonnegative numbers. An exclusion operator “!” can also be used to exclude the number or place immediately following the operator.

For explicit lists, the meaning of the numbers and how the numbering is done for a list of nonnegative numbers are implementation defined. Generally, the numbers represent the smallest unit of execution exposed by the execution environment, typically a hardware thread.

Intervals can be specified using the
    <lower-bound> : <length> : <stride> notation to represent the following list of numbers:

"<lower-bound>, <lower-bound> + <stride>, ..., <lower-bound> +(<length>-1)*<stride>."

When <stride> is omitted, a unit stride is assumed. Intervals can specify numbers within a place as well as sequences of places.

# EXPLICIT LIST EXAMPLE setenv OMP_PLACES "{0,1,2,3},{4,5,6,7},{8,9,10,11},{12,13,14,15}" setenv OMP_PLACES "{0:4},{4:4},{8:4},{12:4}" setenv OMP_PLACES "{0:4}:4:4"

The abstract names listed below should be understood by the execution and runtime environment:

•
threads: Each place corresponds to a single hardware thread on the target machine.

•   cores: Each place corresponds to a single core (having one or more hardware threads) on the target machine.

•   ll_caches: Each place corresponds to a set of cores that share the last level cache on the device.

•   numa_domains: Each place corresponds to a set of cores for which their closest memory on the device is 1) the same memory and 2) at a similar distance from the cores.

•   sockets: Each place corresponds to a single socket (consisting of one or more cores) on the target machine.

When requesting fewer places or more resources than available on the system, the determination of which resources of type
    abstract_name are to be included in the place list is implementation-defined. The precise definitions of the abstract names are implementation defined. An implementation may also add abstract names as appropriate for the target platform. The abstract name may be appended by a positive number in parentheses to denote the length of the place list to be created, that is abstract_name(num-places).

# ABSTRACT NAMES EXAMPLE setenv OMP_PLACES threads setenv OMP_PLACES threads(4)

NOTE: If any numerical values cannot be mapped to a processor on the target platform the behavior is implementation-defined. The behavior is also implementation-defined when the OMP_PLACES environment variable is defined using an abstract name.

OMP_PROC_BIND (Windows, Linux)
    Sets the thread affinity policy to be used for parallel regions at the corresponding nested level. Enables (TRUE) or disables (FALSE) the binding of threads to processor contexts. If enabled, this is the same as specifying KMP_AFFINITY=scatter. If disabled, this is the same as specifying KMP_AFFINITY=none.

Acceptable values:
    TRUE, FALSE, or a comma separated list, each element of which is one of the following values: PRIMARY, MASTER (deprecated), CLOSE, SPREAD.

Default:
    FALSE

If set to
    FALSE, the execution environment may move OpenMP threads between OpenMP places, thread affinity is disabled, and proc_bind clauses on parallel constructs are ignored. Otherwise, the execution environment should not move OpenMP threads between OpenMP places, thread affinity is enabled, and the initial thread is bound to the first place in the OpenMP place list.

If set to
    PRIMARY, all threads are bound to the same place as the primary thread. If set to CLOSE, threads are bound to successive places, close to where the primary thread is bound. If set to SPREAD, the primary thread's partition is subdivided and threads are bound to single place successive sub-partitions.

NOTE: KMP_AFFINITY takes precedence over GOMP_CPU_AFFINITY and OMP_PROC_BIND. GOMP_CPU_AFFINITY takes precedence over OMP_PROC_BIND.

OMP_SCHEDULE
    Sets the runtime schedule type and an optional chunk size.

Default: static, no chunk size specified

Example syntax: OMP_SCHEDULE="[modifier:]kind[,chunk_size]" where

    •   modifier is one of monotonic or nonmonotonic

    •   kind is one of static, dynamic, guided, or auto

    •   chunk_size is a positive integer

= = = = = = = = = =

NOTE: Some environment variables are available for both Intel(R) microprocessors and non-Intel microprocessors, but may perform additional optimizations for Intel(R) microprocessors than for non-Intel microprocessors. = = = = = = = = = =

OMP_STACKSIZE
    Sets the number of bytes to allocate for each OpenMP thread to use as the private stack for the thread. Recommended size is 16M.

Use the optional suffixes to specify byte units:
    B (bytes), K (Kilobytes), M (Megabytes), G (Gigabytes), or T (Terabytes) to specify the units. If you specify a value without a suffix, the byte unit is assumed to be K (Kilobytes).

This variable does not affect the native operating system threads created by the user program, or the thread executing the sequential part of an OpenMP program.

The kmp_{set,get}_stacksize_s() routines set/retrieve the value. The kmp_set_stacksize_s() routine must be called from sequential part, before first parallel region is created. Otherwise, calling kmp_set_stacksize_s() has no effect.

Default (Intel(R) 64 architecture): 4M

Related environment variables: KMP_STACKSIZE (overrides
    OMP_STACKSIZE).

Syntax: OMP_STACKSIZE=value

OMP_THREAD_LIMIT
    Limits the number of simultaneously-executing threads in an OpenMP program.

If this limit is reached and another native operating system thread encounters OpenMP API calls or constructs, the program can abort with an error message. If this limit is reached when an OpenMP parallel region begins, a one-time warning message might be generated indicating that the number of threads in the team was reduced, but the program will continue.

This environment variable is only used for programs compiled with the following option:

The omp_get_thread_limit() routine returns the value of the limit.

Default: No enforced limit

Related environment variable: KMP_ALL_THREADS (overrides
    OMP_THREAD_LIMIT).

Example syntax: OMP_THREAD_LIMIT=value

OMP_WAIT_POLICY
    Decides whether threads spin (active) or yield (passive) while they are waiting.

OMP_WAIT_POLICY=ACTIVE is an alias for
    KMP_LIBRARY=turnaround, and OMP_WAIT_POLICY=PASSIVE is an alias for KMP_LIBRARY=throughput.

Default:
    Passive

Syntax: OMP_WAIT_POLICY=value

OMP_DISPLAY_AFFINITY
    Instructs the runtime to display formatted affinity information for all OpenMP threads in the parallel region upon entering the first parallel region and when any change occurs in the information accessible by the format specifiers listed in the OMP_AFFINITY_FORMAT entry.

Possible values:
    TRUE or FALSE

Default:
    FALSE

OMP_AFFINITY_FORMAT
    Defines the format when displaying OpenMP thread affinity information. Possible values are any string with the following format field available:

    •   %t or %{team_num}: Value returned by omp_get_team_num()

    •   %T or %{num_teams}: Value returned by omp_get_num_teams()

    •   %L or %{nesting_level}: Value returned by omp_get_level()

    •   %n or %{thread_num}: Value returned by omp_get_thread_num()

    •   %a or %{ancestor_tnum}: Value returned by omp_get_ancestor_thread_num(omp_get_level() – 1)

    •   %H or %{host}: Name of host device

    •   %P or %{process_id}: Process ID

    •   %i or %{native_thread_id}: Native thread ID on the platform

    •   %A or %{thread_affinity}: List of processor ID on which a thread may execute

Default: 'OMP: pid %P tid %i thread %n bound to OS proc set {%A}'

OMP_MAX_TASK_PRIORITY
    Controls the use of task priorities by setting the initial value.

Possible values: Non-negative integer.

Default:
    0

OMP_TOOL
    Controls whether the OpenMP runtime will try to register a first party tool that uses OMPT interface.

Possible values:
    ENABLED or DISABLED.

Default:
    ENABLED

NOTE: Only the host OpenMP runtime is supported.

OMP_TOOL_LIBRARIES
    Sets a list of first-party tool locations that use the OMPT interface. The list enumerates names of dynamically-loadable libraries with OS-specific path separator.

Default: Empty

NOTE: Only the host OpenMP runtime is supported.

OMP_TOOL_VERBOSE_INIT
    Controls whether the OpenMP runtime will verbosely log the registration of a tool that uses the OMPT interface.

Possible values:

    •   DISABLED: Do not log the registration.

    •   STDOUT: Log the registration to stdout.

    •   STDERR: Log the registration to stderr.

    •   File_Name: Log the registration to the location specified by File_Name.

Default:DISABLED

NOTE: Only the host OpenMP runtime is supported.

OMP_DEBUG
    Controls whether the OpenMP runtime collects information that an OMPD library may need to support a tool.

Possible values:
    ENABLED or DISABLED.

Default: DISABLED

NOTE: Only the host OpenMP runtime is supported.

OMP_ALLOCATOR
    Specifies the default allocator for allocation calls, directives, and clauses that do not specify an allocator.

Default:
    omp_default_mem_alloc

Syntax:
    <PredefinedMemAllocator> | <PredefinedMemSpace> | <PredefinedMemSpace>:<Traits>

Currently supported values for <PredefinedMemAllocator> and <PredefinedMemSpace> :

    •   omp_default_mem_alloc and omp_default_mem_space

Additional values are supported if
    libmemkind is available and there is system support for it:

    •   omp_high_bw_mem_alloc and omp_high_bw_mem_space

    •   omp_large_cap_mem_alloc and omp_large_cap_mem_space

Refer to the
    OpenMP specification for more information.

OMP_NUM_TEAMS
    Sets the maximum number of teams created by a teams construct by setting nteams-var ICV.

Possible values: Positive integer.

Default: 1

OMP_TEAMS_THREAD_LIMIT
    Sets the maximum number of OpenMP threads to use in each team created by a teams construct.

Possible values: Positive integer.

Default: <NumberOfProcessors> / <nteams-var ICV>

KMP_AFFINITY (Linux, Windows)
    Enables runtime library to bind threads to physical processing units.

You must set this environment variable before the first parallel region, or certain API calls including
    omp_get_max_threads(), omp_get_num_procs() and any affinity API calls. For detailed information on this environment variable, see Thread Affinity Interface.

Default: noverbose,warnings,noreset,respect,granularity=core,none

Default (Windows with multiple processor groups): noverbose,warnings,noreset,norespect,granularity=group,compact,0,0

NOTE: On Windows with multiple processor groups, the norespect affinity modifier is assumed when the process affinity mask equals a single processor group (which is default on Windows). Otherwise, the respect affinity modifier is used.

KMP_ALL_THREADS
    Limits the number of simultaneously-executing threads in an OpenMP program. If this limit is reached and another native operating system thread encounters OpenMP API calls or constructs, then the program may abort with an error message. If this limit is reached at the time an OpenMP parallel region begins, a one-time warning message may be generated indicating that the number of threads in the team was reduced, but the program will continue execution.

This environment variable is only used for programs compiled with the
    qopenmp option.

Default: No enforced limit.

KMP_BLOCKTIME
    Sets the time, in milliseconds, that a thread should wait, after completing the execution of a parallel region, before sleeping.

Use the optional character suffixes:
    s (seconds), m (minutes), h (hours), or d (days) to specify the units.

Specify
    infinite for an unlimited wait time.

Default: 200 milliseconds

Related Environment Variable: KMP_LIBRARY environment variable.

KMP_CPUINFO_FILE
    Specifies an alternate file name for a file containing the machine topology description. The file must be in the same format as /proc/cpuinfo.

Default: None

KMP_DETERMINISTIC_REDUCTION
    Enables (TRUE) or disables (FALSE) the use of a specific ordering of the reduction operations for implementing the reduction clause for an OpenMP parallel region. This has the effect that, for a given number of threads, in a given parallel region, for a given data set and reduction operation, a floating point reduction done for an OpenMP reduction clause has a consistent floating point result from run to run, since round-off errors are identical.

NOTE: When compiling, you must set the following flag to ensure correct behavior:

•   -fp-model precise (Linux)

•   -fp:precise (Windows)

Default: FALSE

KMP_DYNAMIC_MODE
    Selects the method used to determine the number of threads to use for a parallel region when OMP_DYNAMIC=TRUE. Possible values: (asat | load_balance | thread_limit), where,

•   asat: estimates number of threads based on parallel start time;

NOTE: Support for asat (automatic self-allocating threads) is now deprecated and will be removed in a future release.

•   load_balance: tries to avoid using more threads than available execution units on the machine;

•   thread_limit: tries to avoid using more threads than total execution units on the machine.

Default (Intel(R) 64 architecture): load_balance (on all supported OSes)

KMP_HOT_TEAMS_MAX_LEVEL
    Sets the maximum nested level to which teams of threads will be hot.

NOTE: A hot team is a team of threads optimized for faster reuse by subsequent parallel regions. In a hot team, threads are kept ready for execution of the next parallel region, in contrast to the cold team, which is freed after each parallel region, with its threads going into a common pool of threads.

For values of 2 and above, nested parallelism should be enabled.

Default: 1

KMP_HOT_TEAMS_MODE
    Specifies the runtime behavior when the number of threads in a hot team is reduced.

Possible values:

    •   0: Extra threads are freed and put into a common pool of threads.

    •   1: Extra threads are kept in the team in reserve, for faster reuse in subsequent parallel regions.

Default: 0

KMP_HW_SUBSET
    Specifies the subset of available hardware resources for the hardware topology hierarchy. The subset is specified in terms of number of units per upper layer unit starting from top layer downwards. For example, it can specify the number of sockets (top layer units), cores per socket, and the threads per core, to use with an OpenMP application. It is a convenient alternative to writing complicated explicit affinity settings or a limiting process affinity mask. You can also specify an offset value to set which resources to use. When available, you can specify attributes to select different subsets of resources.

An extended syntax is available when
    KMP_TOPOLOGY_METHOD=hwloc. Depending on what resources are detected, you may be able to specify additional resources, such as NUMA nodes and groups of hardware resources that share certain cache levels.

Basic syntax:

[num_units]ID[@offset][:attribute] [,[num_units]ID[@offset][:attribute]...]

where

    •   num_units is either a positive integer, which requests an exact number of resources, or an asterisk (*), which means using all available resources at that layer (for example, using all cores per socket). If num_units is not specified, the asterisk (*) semantics are assumed.

    •   ID is a supported ID:

    S - socket num_units specifies the requested number of sockets. D - die num_units specifies the requested number of dies per socket. C - core num_units specifies the requested number of cores per die - if any - otherwise, per socket. T - thread num_units specifies the requested number of HW threads per core. Supported unit IDs are not case-sensitive.

    •   offset is the number of units to skip (optional).

    •   attribute is an attribute differentiating resources at a particular layer (optional). This is only available for the core layer on machines with Intel(R) Hybrid Technology. The attributes available to users are:

        •   Core type: Either intel_atom or intel_core

        •   Core efficiency: Specified as effnum where num is a number from 0 to the number of core efficiencies detected in the machine topology minus one. For example: eff0. The greater the efficiency number, the more performant the core. There may be more core efficiencies than core types, which can be viewed by setting KMP_AFFINITY=verbose.

NOTE: The hardware cache can be specified as a unit, for example L2 for L2 cache, or LL for last level cache.

Extended syntax when
    KMP_TOPOLOGY_METHOD=hwloc:

Additional IDs can be specified if detected. For example:

N - numa
    num_units specifies the requested number of NUMA nodes per upper layer unit, e.g. per socket.

TI - tile
    num_units specifies the requested number of tiles to use per upper layer unit, e.g. per NUMA node.

When any
    numa or tile units are specified in KMP_HW_SUBSET, the KMP_TOPOLOGY_METHOD will be automatically set to hwloc,so there is no need to set it explicitly.

If you don't specify one or more types of resource, such as socket or thread, all available resources of that type are used.

The runtime library prints a warning, and the setting of
    KMP_HW_SUBSET is ignored if:

    •   a resource is specified, but detection of that resource is not supported by the chosen topology detection method and/or

    •   a resource is specified twice. An exception to this condition is if attributes differentiate the resource.

    •   attributes are used when unavailable, not detected in the machine topology, or conflict with each other.

This variable does not work if the OpenMP affinity is set to
    disabled.

Default: If omitted, the default value is to use all the available hardware resources.

Examples:

    •   2s,4c,2t: Use the first 2 sockets (s0 and s1), the first 4 cores on each socket (c0 - c3), and 2 threads per core.

    •   2s@2,4c@8,2t: Skip the first 2 sockets (s0 and s1) and use 2 sockets (s2-s3), skip the first 8 cores (c0-c7) and use 4 cores on each socket (c8-c11), and use 2 threads per core.

    •   5C@1,3T: Use all available sockets, skip the first core and use 5 cores, and use 3 threads per core.

    •   1T: Use all cores on all sockets, 1 thread per core.

    •   1s, 1d, 1n, 1c, 1t: Use 1 socket, 1 die, 1 NUMA node, 1 core, 1 thread - use HW thread as a result.

    •   4c:intel_atom,5c:intel_core: Use all available sockets and use 4 Intel Atom(R) processor cores and 5 Intel(R) Core(TM) processor cores per socket.

    •   2c:eff0,3c:eff1: Use all available sockets and use 2 cores with efficiency 0 and 3 cores with efficiency 1 per socket.

    •   1s, 1c, 1t: Use 1 socket, 1 core, 1 thread. This may result in using single thread on a 3-layer topology architecture, or multiple threads on 4-layer or 5-layer architecture. Result may even be different on the same architecture, depending on KMP_TOPOLOGY_METHOD specified, as hwloc can often detect more topology layers than default method used by the OpenMP runtime library.

To see the result of the setting, you can specify the
    verbose modifier in for the KMP_AFFINITY environment variable. The OpenMP runtime library will output to stderr stream the information about discovered HW topology before and after the KMP_HW_SUBSET setting was applied. For example, on Intel(R) Xeon Phi(TM) 7210 CPU in SNC-4 Clustering Mode, the setting KMP_AFFINITY=verbose KMP_HW_SUBSET=1N,1L2,1L1,1T outputs various verbose information to stderr, including the following lines about discovered HW topology before and after KMP_HW_SUBSET was applied:

    •   Info #191: KMP_AFFINITY: 1 socket x 4 NUMA domains/socket x 8 tiles/NUMA domain x 2 cores/tile x 4 threads/core. (64 total cores)

    •   Info #191: KMP_HW_SUBSET 1 socket x 1 NUMA domain/socket x 1 tile/NUMA domain x 1 core/tile x 1 thread/core (1 total cores)

KMP_INHERIT_FP_CONTROL
    Enables (TRUE) or disables (FALSE) the copying of the floating-point control settings of the primary thread to the floating-point control settings of the OpenMP worker threads at the start of each parallel region.

Default: TRUE

KMP_LIBRARY
    Selects the OpenMP runtime library execution mode. The values for this variable are serial, turnaround, or throughput.

Default: throughput

KMP_PLACE_THREADS
    Deprecated; use KMP_HW_SUBSET instead.

KMP_SETTINGS
    Enables (TRUE) or disables (FALSE) the printing of OpenMP runtime library environment variables during program execution. Two lists of variables are printed: user-defined environment variables settings and effective values of variables used by OpenMP runtime library.

Default: FALSE

KMP_STACKSIZE
    Sets the number of bytes to allocate for each OpenMP thread to use as its private stack.

Recommended size is 16m.

Use the optional suffixes to specify byte units:
    B (bytes), K (Kilobytes), M (Megabytes), G (Gigabytes), or T (Terabytes) to specify the units. If you specify a value without a suffix, the byte unit is assumed to be K (Kilobytes).

KMP_STACKSIZE overrides
    GOMP_STACKSIZE, which overrides OMP_STACKSIZE.

Default (Intel(R) 64 architecture): 4m

KMP_TOPOLOGY_METHOD
    Forces OpenMP to use a particular machine topology modeling method.

Possible values are:

    •   all: Lets OpenMP choose which topology method is most appropriate based on the platform and possibly other environment variable settings.

    •   cpuid_leaf11: Decodes the APIC identifiers as specified by leaf 11 of the cpuid instruction.

    •   cpuid_leaf4: Decodes the APIC identifiers as specified in leaf 4 of the cpuid instruction.

    •   cpuinfo: If KMP_CPUINFO_FILE is not specified, forces OpenMP to parse /proc/cpuinfo to determine the topology (Linux only). If KMP_CPUINFO_FILE is specified as described above, uses it (Windows or Linux).

    •   flat: Models the machine as a flat (linear) list of processors.

    •   hwloc: Models the machine as the Portable Hardware Locality* (hwloc) library does. This model is the most detailed and includes, but is not limited to: numa nodes, packages, cores, hardware threads, caches, and Windows processor groups.

Default: all

KMP_USER_LEVEL_MWAIT
    Enables (TRUE) or disables (FALSE) the use of user-level mwait as alternative to putting waiting threads to sleep, if available, either from ring3 or WAITPKG.

Default: FALSE

KMP_VERSION
    Enables (TRUE) or disables (FALSE) the printing of OpenMP runtime library version information during program execution.

Default: FALSE

KMP_WARNINGS
    Enables (TRUE) or disables (FALSE) displaying warnings from the OpenMP runtime library during program execution.

Default: TRUE

OpenMP Offload Environment Variables (OMP_, LIBOMPTARGET)

OMP_TARGET_OFFLOAD
    Controls the program behavior when offloading a target region.

Possible values:

    •   MANDATORY: Program execution is terminated if a device construct or device memory routine is encountered and the device is not available or is not supported.

    •   DISABLED: Disables target offloading to devices and execution occurs on the host.

    •   DEFAULT: Target offloading is enabled if the device is available and supported.

Default: DEFAULT

LIBOMPTARGET_DEBUG
    Controls whether debugging information will be displayed from the offload runtime.

Possible values:

    •   0: Disabled.

    •   1: Displays basic debug information from the plugin actions such as device detection, kernel compilation, memory copy operations, kernel invocations, and other plugin-dependent actions.

    •   2: Displays which GPU runtime API functions are invoked with which arguments and parameters in addition to the information displayed with value 1.

Default: 0

LIBOMPTARGET_INFO
    Controls whether basic offloading information will be displayed from the offload runtime.

Possible values:

    •   0: Disabled.

    •   1: Prints all data arguments upon entering an OpenMP device kernel.

    •   2: Indicates when a mapped address already exists in the device mapping table.

    •   4: Dump the contents of the device pointer map if target offloading fails.

    •   8: Indicates when an entry is changed in the device mapping table.

    •   32: Indicates when data is copied to and from the device.

Default: 0

LIBOMPTARGET_PLUGIN
    Specifies which offload plugin is used when offloading a target region.

Possible values:

    •   LEVEL_ZERO | LEVEL0 | level_zero | level0: Uses Intel(R) oneAPI Level Zero (Level Zero) offload plugin.

    •   OPENCL | opencl: Uses OpenCL offload plugin.

    •   X86_64 | x86_64: Uses X86_64 plugin.

Default: LEVEL_ZERO

LIBOMPTARGET_DEVICETYPE
    Selects device type to which a target region is offloaded.

Possible values:

    •   GPU | gpu: GPU device is used.

    •   CPU | cpu: CPU device is used.

Offload plugin support for device type:

    •   Level Zero offload plugin only supports GPU type.

    •   OpenCL offload plugin supports both GPU and CPU types.

    •   X86_64 offload plugin ignores this variable.

Default: GPU

LIBOMPTARGET_PLUGIN_PROFILE
    Enables basic plugin profiling and displays the result when program finishes.

Default: Disabled

Syntax:
    <Value>[,usec], where <Value>=1 | T | t

The unit of reported time is microsecond if “,usec” is appended, millisecond otherwise.

LIBOMPTARGET_DYNAMIC_MEMORY_SIZE
    Sets the size of preallocated memory in MB to service malloc calls on the device.

Currently, calls to free memory on the device do not release memory. All the allocated memory is released only when the program exits.

Possible values: Non-negative integer.

Default: 0

OpenMP Offload Environment Variables for Level Zero Offload Plugin

LIBOMPTARGET_LEVEL0_COMPILATION_OPTIONS
    Passes extra build options when building native target program binaries.

Possible values: Valid
    Level Zero build options.

LIBOMPTARGET_DEVICES
    Controls how subdevices or sub-subdevices are exposed to users if device supports subdevices.

Possible values:

    •   DEVICE | device: Only top-level devices are reported as OpenMP devices and subdevice clause is supported.

    •   SUBDEVICE | subdevice: Only first-level subdevices are reported as OpenMP devices and subdevice clause is ignored.

    •   SUBSUBDEVICE | subsubdevice: Only second-level subdevices are reported as OpenMP devices and subdevice clause is ignored.

    •   ALL | all: All devices and subdevices are reported as OpenMP devices and subdevice clause is ignored.

Default: DEVICE

LIBOMPTARGET_LEVEL0_MEMORY_POOL
    Controls memory pool configuration.

Possible values:

    •   0 : Disables using memory pool.

    •   <PoolInfoList>=<PoolInfo>[,<PoolInfoList>] <PoolInfo>=<MemType>[,<AllocMax>[,<Capacity>[,<PoolSize>]]] <MemType>=all | device | host | shared <AllocMax> is a positive integer or empty <Capacity> is a positive integer or empty <PoolSize> is a positive integer or empty <AllocMax> means maximum allocation size in MB supported by the pool, <Capacity> means number of allocations supported by a single memory block allocated from the Level Zero runtime, and <PoolSize> means maximum size of the total pool size in MB.

Examples:

    •   all,2,8,1024: Enables memory pool for all memory types which can allocate up to eight 2MB blocks from a single block allocated from Level Zero with 1GB total pool size allowed.

    •   device,1,4,512: Enables memory pool only for device memory type which can allocate up to four 1MB blocks from a single block allocated from Level Zero with 512MB total pool size allowed.

Default: all,1,4,256

LIBOMPTARGET_LEVEL0_USE_COPY_ENGINE
    Disables use of copy engine for memory transfers.

Possible values:

    •   0 | F | f: Disables use of copy engine.

Default: Enabled

LIBOMPTARGET_LEVEL0_DEFAULT_TARGET_MEM
    Selects memory type returned by the omp_target_alloc routine.

Possible values:

    •   DEVICE | device: Returned memory type is device type. Device owns the memory and data movement is explicit.

    •   SHARED | shared: Returned memory type is shared type. Ownership of the memory is shared between host and device, and data movement is implicit.

    •   HOST | host: Returned memory type is host type. Host owns the memory and data movement is implicit.

Default: DEVICE

LIBOMPTARGET_LEVEL0_STAGING_BUFFER_SIZE
    Sets the staging buffer size in KB that is used in data transfer between host and device.

Possible values: Non-negative integers where 0 disables use of staging buffer.

Default: 4

OpenMP Offload Environment Variables for OpenCL Offload Plugin

LIBOMPTARGET_OPENCL_COMPILATION_OPTIONS
    Passes extra compilation options when compiling target programs from SPIRV target images.

Possible values: Valid
    OpenCL compilation options.

LIBOMPTARGET_OPENCL_LINKING_OPTIONS
    Passes extra linking options when linking target programs.

Possible values: Valid
    OpenCL linking options.

LIBOMPTARGET_OPENCL_USE_SVM
    Enables or disables using OpenCL SVM memory for default target memory type.

Possible values:

    •   1 | T | t: Enables using OpenCL SVM memory.

    •   0 | F | f: Disables using OpenCL SVM memory.

Default: Disabled

LIBOMPTARGET_OPENCL_DATA_TRANSFER_METHOD
    Selects memory transfer method to use. This is only effective when OpenCL SVM memory is enabled by setting LIBOMPTARGET_OPENCL_USE_SVM.

Possible values:

    •   0: Uses clEnqueueRead and WriteBuffer API on a temporary OpenCL buffer.

    •   1: Uses clEnqueueSVMMap and Unmap API.

    •   2: Uses clEnqueueSVMMemcpy API.

Default: 1

DPC++ Environment Variables

DPCPP_CPU_CU_AFFINITY
    Set thread affinity to CPU. The value and meaning is the following:

    •   close - threads are pinned to CPU cores successively through available cores.

    •   spread - threads are spread to available cores.

    •   master - threads are put in the same cores as master. If DPCPP_CPU_CU_AFFINITY is set, master thread is pinned as well, otherwise master thread is not pinned

This environment variable is similar to the OMP_PROC_BIND variable used by OpenMP.

Default:
    Not set

DPCPP_CPU_NUM_CUS
    Set the numbers threads used for kernel execution.

To avoid over subscription, maximum value of
    DPCPP_CPU_NUM_CUS should be the number of hardware threads. If DPCPP_CPU_NUM_CUS is 1, all the workgroups are executed sequentially by a single thread and this is useful for debugging.

This environment variable is similar to OMP_NUM_THREADS variable used by OpenMP.

Default:
    Not set. Determined by Intel(R) oneAPI Threading Building Blocks (oneTBB).

DPCPP_CPU_PLACES
    Specify the places that affinities are set. The value is { sockets | numa_domains | cores | threads }.

This environment variable is similar to the OMP_PLACES variable used by OpenMP.

If value is numa_domains, oneTBB NUMA API will be used. This is analogous to OMP_PLACES=numa_domains in the OpenMP 5.1 Specification. oneTBB task arena is bound to numa node and SYCL nd range is uniformly distributed to task arenas.

DPCPP_CPU_PLACES is suggested to be used together with
    DPCPP_CPU_CU_AFFINITY.

Default:
    cores

DPCPP_CPU_SCHEDULE
    Specify the algorithm for scheduling work-groups by the scheduler. Currently, DPC++ uses oneTBB for scheduling when using the OpenCL CPU driver. The value selects the petitioner used by the oneTBB scheduler. The value and meaning is the following:

•
dynamic - oneTBB auto_partitioner. It performs sufficient splitting to balance load.

•   affinity - oneTBB affinity_partitioner. It improves auto_partitioner's cache affinity by its choice of mapping subranges to worker threads compared to

•   static - oneTBB static_partitioner. It distributes range iterations among worker threads as uniformly as possible. oneTBB partitioner relies grain-size to control chunking. Grain-size is 1 by default, indicating every work-group can be executed independently.

Default:
    dynamic

The following table summarizes CPU environment variables that are recognized at runtime.

TECHNICAL SUPPORT

You can find product documentation for many released products at: https://software.intel.com/content/www/us/en/develop/documentation.html

  Product Website and Support

To find product information, register your product, or contact Intel, visit: https://software.intel.com/content/www/us/en/develop/support.html. At the support site, you will find comprehensive product information, including:

•   Links to Get Started, Documentation, Individual Support, and Registration.

•   Links to information such as white papers, articles, and user forums.

•   Links to product information.

•   Links to news and events.

  Online Service Center

For more information about the Online Service Center visit: https://supporttickets.intel.com/servicecenter

NOTE: To access support, you must register your product at the Intel Registration Center: https://registrationcenter.intel.com/en/products/

  Release Notes

For detailed information on system requirements, late changes to the products, supported architectures, operating systems, and Integrated Development Environments (IDE) see the Release Notes for the product.

  Forums

You can find helpful information in the Intel Software user forums. You can also submit questions to the forums.

To see the list of the available forums, go to https://community.intel.com/t5/Software-Development-Tools/ct-p/software-dev-tools.

SEE ALSO

Your compiler documentation has additional reference material on features of your compiler.

Notices and Disclaimers

Intel technologies may require enabled hardware, software or service activation.

No product or component can be absolutely secure.

Your costs and results may vary.

(C) Intel Corporation. Intel, the Intel logo, and other Intel marks are trademarks of Intel Corporation or its subsidiaries. Other names and brands may be claimed as the property of others.

Product and Performance Information

= = = = = = = = = =

Performance varies by use, configuration and other factors. Learn more at
    www.Intel.com/PerformanceIndex.

Notice revision #20201201

= = = = = = = = = =

No license (express or implied, by estoppel or otherwise) to any intellectual property rights is granted by this document.

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

Intel disclaims all express and implied warranties, including without limitation, the implied warranties of merchantability, fitness for a particular purpose, and non-infringement, as well as any warranty arising from course of performance, course of dealing, or usage in trade.