The standard compiler options are described in the OPTIONS section. The
       derived compiler options are described in the section entitled Compiler
       Options for Intel(R) C++ Compiler Standard Edition for Embedded Systems
       with Bi-Endian Technology.

       icc - invokes the Intel(R) C Compiler

       icpc - invokes the Intel(R) C++ Compiler


SYNOPSIS

       icc/icpc [options] file1 [file2 ...]

       where:

       · options represents zero or more compiler options.

       · fileN represents a C/C++ source (.C, .c, .cc, other linkable file.

       NOTE:  The  icpc command uses the same compiler options as the icc com-
       mand. Invoking the compiler using icpc compiles .c and .i files as C++.
       Invoking  the  compiler  using icc compiles .c and .i files as C. Using
       icpc always links in  C++  libraries.  Using  icc  only  links  in  C++
       libraries if C++ source is provided on the command line.


Description - icc/icpc

       The  Intel(R) C++ Compiler is designed to process C and C++ programs on
       Intel(R) architecture- based  systems.  You  can  preprocess,  compile,
       assemble, and link these programs.

       This  document  explains how information and instructions apply differ-
       ently to supported  architectures  (see  your  Release  Notes).   If  a
       description  does  not  explicitly  state  an architecture restriction,
       assume that the description is applicable to  all  supported  architec-
       tures.  See  the  Intel(R) C++ compiler documentation for more detailed
       information than what is presented here.

       When there is a restriction, you will see "Architecture  Restrictions",
       which will show the relevant restriction.

       This  man  page  is intended for Linux* and OS X* users. However, some-
       times you will see shortcuts for option names. You may  see  either  or
       both of the following shortcuts:

       · If  you  see  [Q]option-name, it means that the name of the option is
         the same on Linux*, OS X*, and Windows*, except that the Windows form
         starts  with  a  Q. For example, if you see [Q]ip, the Linux and OS X
         form of the option is -ip and the Windows form of the option is /Qip.

       · If  you see [q or Q]option-name, it means that the name of the option
         is very similar except that the Linux* and OS X* forms start with a q
         and  the  Windows form starts with a Q. For example, if you see [q or
         Q]opt-report, the Linux and OS X form of the option  is  -qopt-report

       The Intel(R) C++ Compiler options that affect GNU* gcc*  interoperabil-
       ity include:

       · -cxxlib

       · -gcc-name

       · -gxx-name

       · -fabi-version

       · -no-gcc (see gcc Predefined Macros for more information)

       The Intel(R) C++ Compiler is interoperable with GNU* gcc* compiler ver-
       sions greater than or equal to 3.2. See the Intel(R) C++ Compiler Docu-
       mentation for more information.


Feature Requirements

       Some features may require that other products also be installed.

       To  use  these  tools  and  features, you need licensed versions of the
       tools and you must have an appropriate supported version of  the  rele-
       vant  product edition. For more information, check your product release
       notes.

       The following table shows components (tools) and some of  the  products
       with which they are included.

       Component          Included with these Products

       Intel(R) VTune(TM) Amplifier
                         Intel(R)   Parallel   Studio   Professional  Edition,
                         Intel(R) Parallel Studio Cluster Edition

       Intel(R) Inspector
                         Intel(R)  Parallel   Studio   Professional   Edition,
                         Intel(R) Parallel Studio Cluster Edition

       Intel(R) Trace Analyzer and Collector
                         Intel(R) Parallel Studio Cluster Edition

       The  following  table  lists dependent features and their corresponding
       required products.

       For certain compiler options, 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.

       For more information about requirements for a particular  product,  see
       http://www.intel.com/software/products/.

       · Feature:  Performance Guide Requirement: Intel(R) VTune(TM) Amplifier

       · Feature: Privatization of static data for the  MPC  unified  parallel
         runtime  Requirement: Appropriate elements of the MultiProcessor Com-
         puting (MPC) framework You need to install the MPC  unified  parallel
         runtime. For more information, see http://mpc.hpcframework.com/

       You  should  also  refer  to  the  Release  Notes  for this product for
       detailed information about system requirements,  late  changes  to  the
       products,  supported  architectures,  operating systems, and Integrated
       Development Environments.


OPTIONS

   Option Alphabetic Summary
       This section contains descriptions of available Intel(R)  C++  Compiler
       options. The options are listed in alphabetical order.

       The  Intel(R)  C++  Compiler  user  documentation contains other option
       information, such as lists of deprecated and removed options.

       -Aname[(value)]

              Specifies an identifier for an assertion.

              Arguments:

              name              Is the identifier for the assertion.

              value             Is an optional value for the assertion.  If  a
                                value  is specified, it must be within quotes,
                                including the parentheses delimiting it.

              Default:

              OFF               Assertions  have  no  identifiers  or   symbol
                                names.

              Description:

              This  option specifies an identifier (symbol name) for an asser-
              tion. It is equivalent to an #assert preprocessing directive.

              Note that this option is not the positive form of the  C++  /QA-
              option.

              On  Linux*  systems, because GCC has deprecated assertions, this
              option has no effect.

              Alternate Options:

              None

       -alias-const
                                interpretation of const.

              Description:

              This  option determines whether the compiler assumes a parameter
              of type pointer-to-const does not alias with a parameter of type
              pointer-to-non-const.  It  implies  an  additional attribute for
              const.

              This functionality complies with the input/output  buffer  rule,
              which  assumes  that  input  and  output buffer arguments do not
              overlap.  This option allows the compiler to do some  additional
              optimizations with those parameters.

              In  C99,  you  can  also get the same result if you additionally
              declare your pointer parameters with the restrict keyword.

              Alternate Options:

              None

       -align

       -noalign

              Determines whether variables and arrays are naturally aligned.

              Architecture Restrictions: Only available on IA-32 architecture

              Arguments:

              None

              Default:

              -noalign          Variables and arrays are aligned according  to
                                the gcc model, which means they are aligned to
                                4-byte boundaries.

              Description:

              This option determines whether variables and  arrays  are  natu-
              rally aligned. Option -align forces the following natural align-
              ment:

              Type              Alignment

              double            8 bytes

              long long         8 bytes

              long double       16 bytes
              Alternate Options:

              None

       -ansi


              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.

              This option sets option fmath-errno.

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

              Alternate Options:

              None

       -ansi-alias

       -no-ansi-alias

              Enables or disables the use of ANSI
                     aliasing rules in optimizations.

              Arguments:

              None

              Default:

              ANSI aliasing rules are disabled in optimizations.

              Linux* and OS X* systems:
                                -ansi-alias  ANSI  aliasing  rules  are
                                enabled in optimizations.

              rules,  you  can specify -no-ansi-alias to ensure program
              correctness.

              When you specify the [Q]ansi-alias option, the ansi-alias
              checker  is enabled by default. To disable the ansi-alias
              checker, you must  specify  -no-ansi-alias-check  (Linux*
              and OS X*) or /Qansi-alias-check- (Windows*).

              Alternate Options:

              Linux and OS X: -fstrict-aliasing

              Windows: None

       -ansi-alias-check

       -no-ansi-alias-check

              Enables or disables the ansi-alias
                     checker.

              Architecture  Restrictions:  Not available on Intel(R) 64
              architecture targeting the
                     Intel(R)  Xeon  Phi(TM)  coprocessor  x100 product
                     family (formerly code  name  Knights  Corner),  on
                     IA-32  architecture  targeting  Intel(R)  Graphics
                     Technology, or on Intel(R) 64 architecture target-
                     ing Intel(R) Graphics Technology

              Arguments:

              None

              Default:

              -no-ansi-alias-check
                                The   ansi-alias  checker  is  disabled
                                unless  option   -ansi-alias-check   or
                                /Qansi-alias-check  has been specified.

              Description:

              This option enables or disables the  ansi-alias  checker.
              The  ansi-alias checker checks the source code for poten-
              tial violations  of  ANSI  aliasing  rules  and  disables
              unsafe optimizations related to the code for those state-
              ments that are identified as potential violations.

              You can use option –Wstrict-aliasing to identify  poten-
              tial violations.

              If  the  [Q]ansi-alias  option  has  been  specified, the
                     can be safely shrunk into 32-bit longs.

              Architecture  Restrictions: Only available on Intel(R) 64
              architecture

              Arguments:

              None

              Default:

              OFF               The optimization is not attempted.

              Description:

              This option instructs the compiler to analyze the program
              to determine if there are 64-bit  pointers  that  can  be
              safely  shrunk  into  32-bit  pointers  and  if there are
              64-bit longs (on  Linux*  systems)  that  can  be  safely
              shrunk into 32-bit longs.

              On  OS  X*  systems, you must also specify option -no-pie
              for the optimization to occur.

              For this option to be effective,  the  compiler  must  be
              able to optimize using the [Q]ipo option and must be able
              to analyze all library calls or external calls  the  pro-
              gram  makes.  This option has no effect on Linux* systems
              unless you specify setting SSE3 or higher for option  -x.

              This  option  requires  that the size of the program exe-
              cutable never exceeds 232 bytes and all data  values  can
              be  represented  within  32  bits. If the program can run
              correctly in a  32-bit  system,  these  requirements  are
              implicitly  satisfied. If the program violates these size
              restrictions, unpredictable behavior may occur.

              Alternate Options:

              None

       -auto-p32

              Instructs the compiler to analyze the program  to  deter-
              mine  if  there  are  64-bit  pointers that can be safely
              shrunk to 32-bit pointers.

              Architecture Restrictions: Only available on Intel(R)  64
              architecture

              Arguments:


              For this option to be effective,  the  compiler  must  be
              able  to  optimize  using the -ipo  option and it must be
              able to analyze all library calls or external  calls  the
              program makes. This option has no effect unless you spec-
              ify setting SSE3 or higher for option -x.

              The application cannot exceed  a  32-bit  address  space;
              otherwise, unpredictable results can occur.

              Alternate Options:

              None

       -axcode

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

              Architecture  Restrictions:  Not available on Intel(R) 64
              architecture targeting the
                     Intel(R)  Xeon  Phi(TM)  coprocessor  x100 product
                     family (formerly code  name  Knights  Corner),  on
                     IA-32  architecture  targeting  Intel(R)  Graphics
                     Technology, or on Intel(R) 64 architecture target-
                     ing Intel(R) Graphics Technology

              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 Stream-
                                ing  SIMD  Extensions  (SSSE). Possible
                                values are:

                                COMMON-AVX512  May  generate   Intel(R)
                                               Advanced  Vector  Exten-
                                               sions   512    (Intel(R)
                                               AVX-512)      Foundation
                                               instructions,   Intel(R)
                                               AVX-512  Conflict Detec-
                                               tion  instructions,   as
                                               well as the instructions
                                               enabled with  CORE-AVX2.

                                MIC-AVX512     May   generate  Intel(R)
                                               Advanced  Vector  Exten-
                                               This   keyword  is  only
                                               available  on   Windows*
                                               and Linux*.

                                CORE-AVX512    May   generate  Intel(R)
                                               Advanced  Vector  Exten-
                                               sions    512   (Intel(R)
                                               AVX-512)      Foundation
                                               instructions,   Intel(R)
                                               AVX-512 Conflict  Detec-
                                               tion       instructions,
                                               Intel(R) AVX-512 Double-
                                               word     and    Quadword
                                               instructions,   Intel(R)
                                               AVX-512  Byte  and  Word
                                               instructions         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  Exten-
                                               sions 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  instruc-
                                               tion,  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  Exten-
                                               sions   (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
                                               on Intel(R) 64 architec-
                                               ture.    This   replaces
                                               value T, which is depre-
                                               cated.

                                SSE3           May   generate  Intel(R)
                                               SSE3,  SSE2,   and   SSE
                                               instructions         for
                                               Intel(R) processors. For
                                               OS   X*   systems,  this
                                               value is only  supported
                                               on IA-32 architecture.

                                SSE2           May   generate  Intel(R)
                                               SSE2  and  SSE  instruc-
                                               tions  for Intel(R) pro-
                                               cessors. This  value  is
                                               not  available  on OS X*
                                               systems.

              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*: -m and -x

                                · OS X*: -x

              Description:

              This option tells the compiler to generate multiple, fea-
              ture-specific auto-dispatch code paths for Intel(R)  pro-
              cessors if there is a performance benefit. It also gener-
              ates 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 -m or  -x  (Linux*  and  OS  X*)  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 optimiza-
              tion 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 base-
              advantage of features of the specified  instruction  fea-
              tures.

              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  fea-
              ture-specific  version  of a function and a baseline ver-
              sion of the function. At run time, one of the versions is
              chosen to execute, depending on the Intel(R) processor in
              use. In this way, the program can  benefit  from  perfor-
              mance  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  com-
              bining them. For example, you can specify -axSSE4.1,SSSE3
              (Linux and OS X) or /QaxSSE4.1,SSSE3 (Windows). You  can-
              not combine the old style, deprecated options and the new
              options. For  example,  you  cannot  specify  -axSSE4.1,T
              (Linux and OS X) or /QaxSSE4.1,T (Windows).


              Optimization Notice


              = = = = = = = = = =

              Intel's  compilers  may  or  may not optimize to the same
              degree for non-Intel  microprocessors  for  optimizations
              that are not unique to Intel microprocessors. These opti-
              mizations include SSE2, SSE3, and SSSE3 instruction  sets
              and  other  optimizations.  Intel  does not guarantee the
              availability,  functionality,  or  effectiveness  of  any
              optimization   on  microprocessors  not  manufactured  by
              Intel.  Microprocessor-dependent  optimizations  in  this
              product  are intended for use with Intel microprocessors.
              Certain optimizations not specific to  Intel  microarchi-
              tecture  are  reserved  for Intel microprocessors. Please
              refer to the applicable product User and Reference Guides
              for  more  information regarding the specific instruction
              sets covered by this notice.

              Notice revision #20110804

              = = = = = = = = = =

              Alternate Options:

              None

                                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 com-
              mand 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

       -Bdynamic (L*X only)

              Enables dynamic linking of libraries at run time.

              Arguments:

              None

              Default:

              OFF               Limited dynamic linking occurs.

              Description:

              This option enables dynamic linking of libraries  at  run
              time.  Smaller  executables  are created than with static
              linking.

              This option is placed in the linker command  line  corre-

              Enables static linking of a user's library.

              Arguments:

              None

              Default:

              OFF               Default static linking occurs.

              Description:

              This option enables static linking of a user's library.

              This option is placed in the linker command  line  corre-
              sponding  to  its  location  on the user command line. It
              controls the linking behavior  of  any  library  that  is
              passed using the command line.

              All  libraries  on  the  command  line  following  option
              -Bstatic are linked statically until the end of the  com-
              mand line or until a -Bdynamic option is encountered. The
              -Bdynamic option enables dynamic linking of libraries.

              Alternate Options:

              None

       -Bsymbolic (L*X only)

              Binds references to all global symbols in  a  program  to
              the definitions within a user's shared library.

              Arguments:

              None

              Default:

              OFF               When a program is linked  to  a  shared
                                library, it can override the definition
                                within the shared library.

              Description:

              This option binds references to all global symbols  in  a
              program   to  the  definitions  within  a  user's  shared
              library.

              This option is only meaningful on Executable Linkage For-
              mat (ELF) platforms that support shared libraries.

              None

              Default:

              OFF               When a program is linked  to  a  shared
                                library, it can override the definition
                                within the shared library.

              Description:

              This option binds references to all global function  sym-
              bols  in  a  program  to  the definitions within a user's
              shared library.

              This option is only meaningful on Executable Linkage For-
              mat (ELF) platforms that support shared libraries.

              CAUTION:  This option can have unintended side-effects of
              disabling symbol preemption in the shared library.

              Alternate Options:

              None

       -c

              Prevents linking.

              Arguments:

              None

              Default:

              OFF               Linking is performed.

              Description:

              This option prevents linking. 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.

              Alternate Options:

              None

       -C

              This  option  places  (or  preserves) comments in prepro-
              cessed source output.

              Comments following preprocessing directives, however, are
              not preserved.

              Alternate Options:

              None

       -check=keyword[,
              keyword...]

       /check:keyword[,
              keyword...]

              Checks for certain conditions at run
                     time.

              Arguments:

              keyword           Specifies the conditions to check. Pos-
                                sible values are:

                                [no]conversions
                                               Determines       whether
                                               checking occurs for con-
                                               verting    to    smaller
                                               types.  Keyword  conver-
                                               sions    enables    this
                                               checking.

                                [no]stack      Determines       whether
                                               checking occurs  on  the
                                               stack   frame.   Keyword
                                               stack    enables    this
                                               checking.  If  stack  is
                                               specified, the stack  is
                                               checked for buffer over-
                                               runs and  buffer  under-
                                               runs.  This  option also
                                               enforces local variables
                                               initialization and stack
                                               pointer verification.

                                [no]uninit     Determines       whether
                                               checking    occurs   for
                                               uninitialized variables.
                                               Keyword  uninit  enables
                                               this  checking.   If   a
                                               variable  is read before
                                               classes,    unions    or
                                               arrays.

              Default:

              noconversions nostack nouninit
                                No  checking is performed for the above
                                run-time conditions.

              Description:

              This option checks for certain conditions at run time.

              On Windows* systems, this option disables any default  or
              specified  optimizations  and  applies  the  /Od level of
              optimization. If you specified  optimizations,  the  com-
              piler  emits  warning  diagnostics for the disabled opti-
              mizations.

              On Linux* and OS X* systems, this option may disable some
              optimizations.

              NOTE:  This option requires library support. Depending on
              the platform, the required  library  is  either  in  your
              operating system run-time environment or in your compiler
              package.

              Alternate Options:

              check conversions Linux and OS X: None

              check             stack Linux and OS X: None

              check             uninit Linux and OS X: None

       -check-pointers=keyword (L*X only)

              Determines whether the compiler checks
                     bounds for memory access through pointers.

              Architecture Restrictions: Not available on  Intel(R)  64
              architecture targeting the
                     Intel(R) Xeon  Phi(TM)  coprocessor  x100  product
                     family  (formerly  code  name  Knights Corner), on
                     IA-32  architecture  targeting  Intel(R)  Graphics
                     Technology, or on Intel(R) 64 architecture target-
                     ing Intel(R) Graphics Technology

              Arguments:

              keyword           Specifies what type of bounds  checking
                                occurs.  Possible values are:

              -check-pointers=none or
                                /Qcheck-pointers:none  No bounds check-
                                ing occurs for  memory  access  through
                                pointers.

              Description:

              This option determines whether the compiler checks bounds
              for memory access through pointers. It  enables  checking
              of  all indirect accesses through pointers, and all array
              accesses.

              The compiler may optimize these checks away when  it  can
              determine that an access is safe.

              When  rw  or  write  is  specified,  the  [Q]check-point-
              ers-undimensioned option is set and dimensioned and undi-
              mensioned arrays are checked.

              If you do not want undimensioned arrays checked, you must
              specify option the negative form of the option (see  Syn-
              tax above).

              This  pointer  checker  feature  requires installation of
              another  product.  For  more  information,  see   Feature
              Requirements.

              Alternate Options:

              None

       -check-pointers-dangling=keyword (L*X only)

              Determines whether the compiler checks
                     for dangling pointer references.

              Architecture  Restrictions:  Not available on Intel(R) 64
              architecture targeting the
                     Intel(R)  Xeon  Phi(TM)  coprocessor  x100 product
                     family (formerly code  name  Knights  Corner),  on
                     IA-32  architecture  targeting  Intel(R)  Graphics
                     Technology, or on Intel(R) 64 architecture target-
                     ing Intel(R) Graphics Technology

              Arguments:

              keyword           Specifies what type of dangling pointer
                                checking occurs. Possible values are:

                                none           Disables  checking   for
                                               dangling  pointer refer-
                                               ences.   This   is   the

              Default:

              -check-pointers-dangling=none or
                                /Qcheck-pointers-dangling:none       No
                                checking  occurs  for  dangling pointer
                                references.

              Description:

              This option determines whether the  compiler  checks  for
              dangling pointer references.

              To   use   this   option,   you  must  also  specify  the
              [Q]check-pointers option.

              This pointer checker  feature  requires  installation  of
              another   product.  For  more  information,  see  Feature
              Requirements.

              Alternate Options:

              None

       -check-pointers-mpx=keyword (L*X only)

              Determines whether the compiler checks
                     bounds for memory access through pointers on  pro-
                     cessors  that  support  Intel(R) Memory Protection
                     Extensions (Intel(R) MPX).

              Architecture Restrictions: Not available on  Intel(R)  64
              architecture targeting the
                     Intel(R) Xeon  Phi(TM)  coprocessor  x100  product
                     family  (formerly  code  name  Knights Corner), on
                     IA-32  architecture  targeting  Intel(R)  Graphics
                     Technology, or on Intel(R) 64 architecture target-
                     ing Intel(R) Graphics Technology

              Arguments:

              keyword           Specifies what type of bounds  checking
                                occurs.  Possible values are:

                                none           Disables  bounds  check-
                                               ing.   This    is    the
                                               default.

                                rw             Checks  bounds for reads
                                               and    writes    through
                                               pointers.

                                write          Checks  bounds  for only

              support Intel(R) MPX. It enables checking of all indirect
              accesses through pointers, and all array accesses.

              The  compiler  may optimize these checks away when it can
              determine that an access is safe.

              If you specify option [Q]check-pointers along with option
              [Q]check-pointers-mpx, option [Q]check-pointers-mpx takes
              precedence.

              If you specify [Q]check-pointers-mpx, you cannot  specify
              option [Q]check-pointers-dangling.

              NOTE:  This feature requires supporting hardware, OS, and
              library support. Intel(R) MPX bounds exceptions are hard-
              ware  exceptions  that are handled by the OS and run-time
              library, similar to the way that a null pointer exception
              is  handled.  Pointer Checker detailed reports and report
              control functions are  not  enabled  with  Intel(R)  MPX,
              because  these  require  overriding the OS exception han-
              dling.

              For more details, see the document titled: Intel(R)  Mem-
              ory   Protection  Extensions  Enabling  Guide,  which  is
              located at http://intel.ly/1QlUdjN

              This pointer checker  feature  requires  installation  of
              another   product.  For  more  information,  see  Feature
              Requirements.

              Alternate Options:

              None

       -check-pointers-narrowing (L*X only)

       -no-check-pointers-narrowing (L*X only)

              Determines whether the compiler enables
                     or disables the narrowing of pointers to structure
                     fields.

              Architecture  Restrictions:  Not available on Intel(R) 64
              architecture targeting the
                     Intel(R)  Xeon  Phi(TM)  coprocessor  x100 product
                     family (formerly code  name  Knights  Corner),  on
                     IA-32  architecture  targeting  Intel(R)  Graphics
                     Technology, or on Intel(R) 64 architecture target-
                     ing Intel(R) Graphics Technology

              Arguments:

              legally point to that field.

              To  use  this  option,  you   must   also   specify   the
              [Q]check-pointers option.

              Disabling  this  feature can improve Pointer Checker com-
              patibility with non-ANSI compliant code.

              To disable the narrowing of pointers to structure fields,
              specify  the  negative  form  of  the  option (see Syntax
              above).

              This pointer checker  feature  requires  installation  of
              another   product.  For  more  information,  see  Feature
              Requirements.

              Alternate Options:

              None

       -check-pointers-undimensioned (L*X only)

       -no-check-pointers-undimensioned (L*X only)

              Determines whether the compiler checks
                     bounds for memory access through arrays  that  are
                     declared without dimensions.

              Architecture  Restrictions:  Not available on Intel(R) 64
              architecture targeting the
                     Intel(R)  Xeon  Phi(TM)  coprocessor  x100 product
                     family (formerly code  name  Knights  Corner),  on
                     IA-32  architecture  targeting  Intel(R)  Graphics
                     Technology, or on Intel(R) 64 architecture target-
                     ing Intel(R) Graphics Technology

              Arguments:

              None

              Default:

              -check-pointers-undimensioned or
                                /Qcheck-pointers-undimensioned   Bounds
                                checking  occurs  for   memory   access
                                through  arrays that are declared with-
                                out dimensions.  This  checking  occurs
                                for  both dimensioned and undimensioned
                                arrays.

              Description:

              undefined symbols when linking library code that has  not
              been  compiled  with pointer checking enabled. In both of
              these  cases,  the  symbols  will  contain   the   string
              cp_array_end.

              To prevent these issues, disable the checking of undimen-
              sioned arrays, by specifying the  negative  form  of  the
              option (see Syntax above).

              Note  that  even  if you specify the negative form of the
              option, dimensioned arrays are always checked.

              Alternate Options:

              None

       -check-uninit

       -no-check-uninit

              Determines  whether  checking  occurs  for  uninitialized
              variables.  This  is a deprecated option. The replacement
              option is -check=uninit.

              Arguments:

              None

              Default:

              -no-check-uninit  No checking  occurs  for  uninitialized
                                variables.

              Description:

              This option determines whether checking occurs for unini-
              tialized variables.  Option  -check-uninit  enables  this
              checking.

              If  a  variable  is read before it is written, a run-time
              error routine will be called.

              Run-time checking of undefined variables is  only  imple-
              mented  on local, scalar variables. It is not implemented
              on dynamically allocated variables, extern  variables  or
              static  variables.  It  is  not  implemented  on structs,
              classes, unions or arrays.

              Alternate Options:

              Linux and OS X: -check=uninit

                                extensions are recognized.

              Description:

              This  option  causes  serialization of code that contains
              Intel(R) Cilk(TM) Plus language  extensions.  This  means
              that  the  compiler  will run the program as if it were a
              C/C++ serialized program.

              This option forces inclusion of  a  special  header  file
              (cilk_stub.h) that includes preprocessor macros that make
              certain specific keywords that are related to those  lan-
              guage extensions invisible to the compiler.

              The  serialization  of a program containing these special
              language  extensions  is  described  in  Using   Intel(R)
              Cilk(TM) Plus.

              NOTE: Vector parallelism, which is generated by the array
              notations within Intel(R) Cilk(TM) Plus, is not  affected
              by this compiler option.

              Alternate Options:

              None

       -clang-name=name (M*X only)

              Specifies the name of the Clang compiler
                     that  should be used to set up the environment for
                     C compilations.

              Architecture Restrictions: Not available on  Intel(R)  64
              architecture targeting the
                     Intel(R) Xeon  Phi(TM)  coprocessor  x100  product
                     family  (formerly  code  name  Knights Corner), on
                     IA-32  architecture  targeting  Intel(R)  Graphics
                     Technology, or on Intel(R) 64 architecture target-
                     ing Intel(R) Graphics Technology

              Arguments:

              name              Is the name of the  Clang  compiler  to
                                use.  It can include the path where the
                                Clang compiler is located.

              Default:

              OFF               The compiler uses the PATH  setting  to
                                find  the  Clang  compiler  and resolve
                                environment settings.

              NOTE: This option applies to the Intel  compiler  running
              in  a  CLANG  environment. It does not apply to the Intel
              CLANG-based compiler.

              Alternate Options:

              None

       -clangxx-name=name (M*X only)

              Specifies the name of the Clang++
                     compiler that should be used to set up  the  envi-
                     ronment for C++ compilations.

              Architecture  Restrictions:  Not available on Intel(R) 64
              architecture targeting the
                     Intel(R)  Xeon  Phi(TM)  coprocessor  x100 product
                     family (formerly code  name  Knights  Corner),  on
                     IA-32  architecture  targeting  Intel(R)  Graphics
                     Technology, or on Intel(R) 64 architecture target-
                     ing Intel(R) Graphics Technology

              Arguments:

              name              Is  the name of the Clang++ compiler to
                                use. It can include the path where  the
                                Clang++ compiler is located.

              Default:

              OFF               The  compiler  uses the PATH setting to
                                find the Clang++ compiler  and  resolve
                                environment settings.

              Description:

              This  option  specifies  the name of the Clang++ compiler
              that should be used to set up  the  environment  for  C++
              compilations.  If you do not specify a path, the compiler
              will search the PATH settings for the compiler  name  you
              provide.

              The  C equivalent to option -clangxx-name is -clang-name.

              NOTE: This option applies to the Intel  compiler  running
              in  a  CLANG  environment. It does not apply to the Intel
              CLANG-based compiler.

              Alternate Options:

              None

              -no-complex-limited-range
                                Basic   algebraic  expansions  of  some
                                arithmetic operations involving data of
                                type COMPLEX are disabled.

              Description:

              This option determines whether the use of basic algebraic
              expansions of some arithmetic operations  involving  data
              of type COMPLEX is enabled.

              When  the  option  is enabled, this can cause performance
              improvements in programs that use a lot of COMPLEX arith-
              metic.  However,  values  at the extremes of the exponent
              range may not compute correctly.

              Alternate Options:

              None

       -cxxlib[=dir] (L*X only)

       -cxxlib-nostd (L*X only)

       -no-cxxlib (L*X only)

              Determines whether  the  compiler  links  using  the  C++
              run-time libraries and header files provided by gcc.

              Arguments:

              dir               Is an optional top-level  location  for
                                the gcc binaries and libraries.

              Default:

              C++: -cxxlib C: -no-cxxlib
                                For C++, the compiler uses the run-time
                                libraries and headers provided by  gcc.
                                For  C,  the  compiler uses the default
                                run-time libraries and headers and does
                                not link to any additional C++ run-time
                                libraries and headers. However, if  you
                                specify  compiler  option -std=gnu++98,
                                the default is -cxxlib.

              Description:

              This option determines whether the compiler  links  using
              the  C++  run-time libraries and header files provided by
              gcc.


              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".

              CAUTION:  On  Linux*  and  OS  X* systems, if you are not
              specifying a value, do not use D  for  name,  because  it
              will conflict with the -DD option.

              Alternate Options:

              None

       -daal[=lib]

              Tells the compiler to link to certain
                     libraries in the Intel(R) Data Analytics Accelera-
                     tion Library (Intel(R) DAAL).

              Architecture Restrictions: Not available on  Intel(R)  64
              architecture targeting the
                     Intel(R)  Xeon  Phi(TM)  coprocessor  (code   name
                     Knights  Landing), on IA-32 architecture targeting
                     Intel(R) Graphics Technology, or  on  Intel(R)  64
                     architecture  targeting Intel(R) Graphics Technol-
                     ogy

              Arguments:

              lib               Indicates which Intel(R)  DAAL  library
                                files should be linked. Possible values

              Default:

              OFF               The  compiler  does  not  link  to  the
                                Intel(R) DAAL.

              Description:

              This  option  tells  the  compiler  to  link  to  certain
              libraries in the  Intel(R)  Data  Analytics  Acceleration
              Library (Intel(R) DAAL).

              On Linux* and OS X* systems, the associated Intel(R) DAAL
              headers are included when you specify this option.

              NOTE: On Windows* systems, this option  is  processed  by
              the  compiler,  which  adds  directives  to  the compiled
              object file that are processed by the linker.  On  Linux*
              and  OS  X*  systems,  this  option  is  processed by the
              icc/icpc command that initiates linking,  adding  library
              names explicitly to the link command.


              Optimization Notice


              = = = = = = = = = =

              Intel's  compilers  may  or  may not optimize to the same
              degree for non-Intel  microprocessors  for  optimizations
              that are not unique to Intel microprocessors. These opti-
              mizations include SSE2, SSE3, and SSSE3 instruction  sets
              and  other  optimizations.  Intel  does not guarantee the
              availability,  functionality,  or  effectiveness  of  any
              optimization   on  microprocessors  not  manufactured  by
              Intel.  Microprocessor-dependent  optimizations  in  this
              product  are intended for use with Intel microprocessors.
              Certain optimizations not specific to  Intel  microarchi-
              tecture  are  reserved  for Intel microprocessors. Please
              refer to the applicable product User and Reference Guides
              for  more  information regarding the specific instruction
              sets covered by this notice.

              Notice revision #20110804

              = = = = = = = = = =

              Alternate Options:

              None

       -dD

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

              Alternate Options:

              None

       -debug [keyword]

              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.

                                [no]emit_column
                                               Determines  whether  the
                                               compiler generates  col-
                                               umn  number  information
                                               for debugging.

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

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

                                [no]macros     Determines  whether  the
                                               compiler emits debugging
                                               information   for  C/C++
                                               macros.

                                               compiler       generates
                                               enhanced  debug informa-
                                               tion useful  in  finding
                                               scalar  local variables.

                                extended       Sets   keyword    values
                                               semantic-stepping    and
                                               variable-locations.

                                [no]parallel (Linux only)
                                               Determines  whether  the
                                               compiler  generates par-
                                               allel debug code instru-
                                               mentations   useful  for
                                               thread data sharing  and
                                               reentrant   call  detec-
                                               tion.

              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  gener-
                                ated.   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  optimiza-
              tion level options (-O3, -O2 or -O3).

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

              Option             Description

              -debug none       Disables generation of debugging infor-
                                mation.


              -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 macros     The  compiler  emits debugging informa-
                                tion for C/C++ macros. This provides  a
                                means  to  describe  the  macros  for a
                                given compilation unit.

              -debug pubnames   The   compiler   generates   a    DWARF
                                debug_pubnames section. This provides a
                                means  to  list  the  names  of  global
                                objects  and functions in a compilation
                                unit.

              -debug semantic-stepping
                                Generates  enhanced  debug  information
                                useful for breakpoints and stepping. It
                                tells the  debugger  to  stop  only  at
                                machine  instructions  that achieve the
                                final effect of a source statement.

              For example, in the case of an assignment
                                statement,  this  might  be   a   store
                                instruction  that  assigns a value to a
                                program variable; for a function  call,
                                it  might  be  the  machine instruction
                                that executes the call. Other  instruc-
                                tions generated for those source state-
                                ments are not  displayed  during  step-
                                ping.

              This option has no impact unless optimizations
                                have also been enabled.

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

              This feature allows the run-time locations of
                                local  scalar variables to be specified
                                more accurately; that is, whether, at a

              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.

              On  OS  X* systems, debuggers read debug information from
              object files. As a result, the executables don't  contain
              any debug information.  Therefore, if you want to be able
              to debug on these systems, you  must  retain  the  object
              files.

              Alternate Options:

              For               -debug  full,  -debug  all,  or  -debug
                                Linux and OS X: -g

              For               -debug variable-locations Linux and  OS
                                X: -fvar-tracking

              For               -debug  semantic-stepping  Linux and OS
                                X: -fvar-tracking-assignments

       -diag-type=diag-list

              Controls the display of diagnostic
                     information during compilation.

              Arguments:

              type              Is an action to perform on diagnostics.
                                Possible values are:

                                enable         Enables   a   diagnostic
                                               message or  a  group  of
                                               messages. If you specify
                                               -diag-enable=all (Linux*
                                               and     OS     X*)    or
                                               /Qdiag-enable:all  (Win-
                                               dows*),  all  diagnostic
                                               messages    shown     in
                                               diag-list are enabled.

                                disable        Disables   a  diagnostic
                                               message or  a  group  of
                                               messages. If you specify
                                               -diag-disable=all
                                               (Linux*  and  OS  X*) or
                                               /Qdiag-disable:all (Win-
                                               dows*),  all  diagnostic
                                               messages    shown     in
                                               diag-list  are disabled.

                                sible values are:

                                driver         Specifies     diagnostic
                                               messages issued  by  the
                                               compiler driver.

                                port-linux     Specifies     diagnostic
                                               messages  for   language
                                               features  that may cause
                                               errors when  porting  to
                                               Linux*   systems.   This
                                               diagnostic group is only
                                               available   on  Windows*
                                               systems.

                                port-win       Specifies     diagnostic
                                               messages  for GNU exten-
                                               sions  that  may   cause
                                               errors  when  porting to
                                               Windows. This diagnostic
                                               group  is only available
                                               on Linux and OS X*  sys-
                                               tems.

                                thread         Specifies     diagnostic
                                               messages  that  help  in
                                               thread-enabling  a  pro-
                                               gram.

                                vec            Specifies     diagnostic
                                               messages  issued  by the
                                               vectorizer.

                                par            Specifies     diagnostic
                                               messages  issued  by the
                                               auto-parallelizer  (par-
                                               allel optimizer).

                                openmp         Specifies     diagnostic
                                               messages issued  by  the
                                               OpenMP* parallelizer.

                                warn           Specifies     diagnostic
                                               messages  that  have   a
                                               "warning"       severity
                                               level.

                                error          Specifies     diagnostic
                                               messages  that  have  an
                                               "error" severity  level.

                                remark         Specifies     diagnostic
                                               commas. There can be  no
                                               intervening  white space
                                               between each id.

                                tag[,tag,...]  Specifies  the  mnemonic
                                               name of one or more mes-
                                               sages.  If  you  specify
                                               more  than  one mnemonic
                                               name, they must be sepa-
                                               rated  by  commas. There
                                               can  be  no  intervening
                                               white space between each
                                               tag.

                                The diagnostic messages  generated  can
                                be affected by certain options, such as
                                [Q]x, /arch (Windows) or -m (Linux  and
                                OS X).

              Default:

              OFF               The  compiler issues certain diagnostic
                                messages by default.

              Description:

              This option controls the display of  diagnostic  informa-
              tion  during  compilation. Diagnostic messages are output
              to stderr unless the [Q]diag-file option is specified.

              To control the diagnostic  information  reported  by  the
              vectorizer,  use  options  [q  or  Q]opt-report and [q or
              Q]opt-report-phase, phase vec.

              To control the diagnostic  information  reported  by  the
              auto-parallelizer,  use options [q or Q]opt-report and [q
              or Q]opt-report-phase, phase par.

              Alternate Options:

              enable vec        Linux   and   OS    X:    -qopt-report;
                                -qopt-report -qopt-report-phase=vec

              disable vec       Linux    and   OS   X:   -qopt-report=0
                                -qopt-report-phase=vec

              enable par        Linux   and   OS    X:    -qopt-report;
                                -qopt-report -qopt-report-phase=par

              disable par       Linux    and   OS   X:   -qopt-report=0
                                -qopt-report-phase=par

              Description:

              This option tells the compiler to print all enabled diag-
              nostic messages and stop compilation. The diagnostic mes-
              sages are output to stdout.

              This  option prints the enabled diagnostics from all pos-
              sible diagnostics that the compiler can issue,  including
              any default diagnostics.

              If  diag-list is specified for the [Q]diag-enable option,
              the print out will include the diag-list diagnostics.

              Alternate Options:

              None

       -diag-enable=power

       -diag-disable=power

              Controls whether diagnostics  are  enabled  for  possibly
              inefficient  code  that  may  affect power consumption on
              IA-32 and Intel(R) 64 architectures.

              Arguments:

              None

              Default:

              -diag-disable=power or
                                /Qdiag-disable:power Power  consumption
                                diagnostics are disabled.

              Description:

              This  option controls whether diagnostics are enabled for
              possibly inefficient code that may affect power  consump-
              tion on IA-32 and Intel(R) 64 architectures.

              If  you  specify option -diag-enable=power (Linux* and OS
              X*) or /Qdiag-enable:power (Windows*), the compiler  will
              detect  various  API calls with argument values in ranges
              known to be inefficient for power consumption. The  diag-
              nostic  issued  will  point out the problem argument; for
              example, "power inefficient use of 'Sleep' with  argument
              in range [0;10]".

              Alternate Options:

              None
              n                 Specifies  the  level  of  severity  to
                                report. Possible values are:

                                1              Reports only diagnostics
                                               with a severity level of
                                               "critical".  Diagnostics
                                               with a severity level of
                                               "error" or "warning" are
                                               not displayed.

                                2              Reports  all diagnostics
                                               with a severity level of
                                               "critical"  and "error".
                                               Diagnostics    with    a
                                               severity level of "warn-
                                               ing" are  not  reported.
                                               This is the default.

                                3              Reports  all diagnostics
                                               regardless of the sever-
                                               ity level.

              mode              Specifies  the  analysis mode. Possible
                                values are:

                                full           This  mode  attempts  to
                                               find  all  program weak-
                                               nesses,  even   at   the
                                               expense  of  more  false
                                               positives. This mode  is
                                               recommended  when  using
                                               the  tool  for  security
                                               assurance.

                                               This  is  the default if
                                               -diag-enable=sc{[1|2|3]}
                                               (Linux* OS and OS X*) or
                                               /Qdiag-enable:sc{[1|2|3]}
                                               (Windows*     OS)     is
                                               present. Otherwise,  the
                                               default  is None (static
                                               analysis diagnostics are
                                               disabled).

                                concise        This  mode  attempts  to
                                               reduce  false  positives
                                               somewhat    more    than
                                               reducing   false   nega-
                                               tives. This mode is rec-
                                               ommended when using  the
                                               tool  for  general error
                                               detection.

                                abled.

              Description:

              This option enables static analysis diagnostics.

              If you specify n for the option, you can determine  which
              diagnostics  to  emit  based on severity.  If you specify
              mode, you can also specify an analysis mode for  diagnos-
              tic messages.

              To  disable  static  analysis,  specify /Qdiag-disable:sc
              (Windows* OS) or option -diag-disable=sc (Linux* OS).

              You can also specify the following  options  that  affect
              the diagnostics:

              · Option [Q]diag-error setting sc This changes all Static
                Analysis diagnostics to errors.

              · Option [Q]diag-warning  setting  sc  This  changes  all
                Static Analysis diagnostics to warnings.

              · Option  [Q]diag-remark  setting  sc  This  changes  all
                Static Analysis diagnostics to remarks (comments).

              This static analysis  feature  requires  installation  of
              another   product.  For  more  information,  see  Feature
              Requirements.

              Alternate Options:

              None

       -diag-enable=sc-enums (L*X only)

              Tells static analysis to treat enumeration  variables  as
              known  values equal to any one of the associated enumera-
              tion literals. This is a deprecated option. There  is  no
              replacement option.

              Arguments:

              None

              Default:

              OFF               If  static  analysis  is  enabled,   it
                                treats unknown enumeration variables as
                                unknown integer values.

              Description:
              Requirements.

              Alternate Options:

              None

       -diag-enable=sc-include (L*X only)

              Tells a source code analyzer to process include files and
              source files when issuing diagnostic messages.  This is a
              deprecated option. There is no replacement option.

              Arguments:

              None

              Default:

              OFF               The  compiler issues certain diagnostic
                                messages by default. If static analysis
                                is  enabled, include files are not ana-
                                lyzed by default.

              Description:

              This option tells the static security analyzer to process
              include  files  and  source files when issuing diagnostic
              messages. Normally, when static analysis diagnostics  are
              enabled, only source files are analyzed.

              This  option is ignored unless you enable static analysis
              diagnostics by specifying option  [Q]diag-enable  setting
              sc[n] or setting sc-mode.

              This  static  analysis  feature  requires installation of
              another  product.  For  more  information,  see   Feature
              Requirements.

              Alternate Options:

              None

       -diag-enable=sc-single-file (L*X only)

              Tells  static analysis to process each file individually.
              This is a deprecated  option.  There  is  no  replacement
              option.

              Arguments:

              None

              sc[n] or setting sc-mode.

              This  static  analysis  feature  requires installation of
              another  product.  For  more  information,  see   Feature
              Requirements.

              Alternate Options:

              None

       -diag-error-limit=n

       -no-diag-error-limit

              Specifies  the  maximum  number  of errors allowed before
              compilation stops.

              Arguments:

              n                 Is the maximum number of error-level or
                                fatal-level compiler errors allowed.

              Default:

              30                A  maximum  of   30   error-level   and
                                fatal-level messages are allowed.

              Description:

              This  option  specifies  the  maximum  number  of  errors
              allowed before compilation stops. It indicates the  maxi-
              mum  number of error-level or fatal-level compiler errors
              allowed for a file specified on the command line.

              If   you   specify   the    negative    form    of    the
              [Q]diag-error-limit  option on the command line, there is
              no limit on the number of errors that are allowed.

              If the maximum number of errors  is  reached,  a  warning
              message  is issued and the next file (if any) on the com-
              mand line is compiled.

              Alternate Options:

              Linux and OS X: -wn (this is a deprecated option)

       -diag-file[=filename] (L*X only)

              Causes the results of diagnostic analysis
                     to be output to a file.

              Arguments:
              You  can  include a file extension in filename. For exam-
              ple, if file.txt is specified, the  name  of  the  output
              file is file.txt. If you do not provide a file extension,
              the name of the file is filename.diag.

              If filename is not specified, the name  of  the  file  is
              name-of-the-first-source-file.diag.   This  is  also  the
              name of the file if the name specified for file conflicts
              with a source file name provided in the command line.

              NOTE: If you specify the [Q]diag-file option and you also
              specify the [Q]diag-file-append option, the  last  option
              specified on the command line takes precedence.

              Alternate Options:

              None

       -diag-file-append[=filename] (L*X only)

              Causes  the results of diagnostic analysis to be appended
              to a file.

              Arguments:

              filename          Is  the name of the file to be appended
                                to. It can include a path.

              Default:

              OFF               Diagnostic  messages  are   output   to
                                stderr.

              Description:

              This  option causes the results of diagnostic analysis to
              be appended to a file. If you do not specify a path,  the
              driver  will  look  for  filename  in the current working
              directory.

              If filename is not found, then a new file with that  name
              is  created in the current working directory. If the name
              specified for file conflicts with a source file name pro-
              vided  in  the  command  line,  the  name  of the file is
              name-of-the-first-source-file.diag.

              NOTE: If you specify the [Q]diag-file-append  option  and
              you also specify the [Q]diag-file option, the last option
              specified on the command line takes precedence.

              Alternate Options:


              -diag-id-numbers  The compiler displays  diagnostic  mes-
                                sages  by using their ID number values.

              Description:

              This option  determines  whether  the  compiler  displays
              diagnostic  messages  by using their ID number values. If
              you specify the negative form of  the  [Q]diag-id-numbers
              option,  mnemonic names are output for driver diagnostics
              only.

              Alternate Options:

              None

       -diag-onceid[,id,...]

              Tells the compiler to issue one or more  diagnostic  mes-
              sages only once.

              Arguments:

              id                Is the ID number of the diagnostic mes-
                                sage. If you specify more than one mes-
                                sage number, they must be separated  by
                                commas.  There  can  be  no intervening
                                white space between each id.

              Default:

              OFF               The compiler issues certain  diagnostic
                                messages by default.

              Description:

              This option tells the compiler to issue one or more diag-
              nostic messages only once.

              Alternate Options:

              Linux: -wo (this is a deprecated option)

              Windows: /Qwo (this is a deprecated option)

       -diag-sc-dir[=dir] (L*X only)

              Specifies a directory for static analysis  results.  This
              is a deprecated option. There is no replacement option.

              Arguments:


              If  you do not specify dir, the results are placed in the
              current working directory.  Results are placed in a  sub-
              directory  with the name rnnnsc, where nnn is replaced by
              the next available sequence number (001, 002, etc.).

              This option is ignored unless you enable static  analysis
              diagnostics  by  specifying option [Q]diag-enable setting
              sc[n] or setting sc-mode.

              Alternate Options:

              None

       -dM

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

              Arguments:

              None

              Default:

              OFF               The compiler does not output macro def-
                                initions after preprocessing.

              Description:

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

              Alternate Options:

              None

       -dN

              Same as option -dD, but output #define directives contain
              only macro names.

              Arguments:

              None

              Default:

              OFF               The  compiler  does  not output #define
                                directives.


              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

              Displays the target machine and operating system configu-
              ration.

              Arguments:

              None

              Default:

              OFF               The compiler does  not  display  target
                                machine  or  operating  system informa-
                                tion.

              Description:

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

              Alternate Options:

              None

       -dumpversion

              Displays the version number of the compiler.

              Arguments:

              None

              Default:

              Specifies a dynamic linker other than the default.

              Arguments:

              file              Is the name of the dynamic linker to be
                                used.

              Default:

              OFF               The default dynamic linker is used.

              Description:

              This option lets you specify a dynamic linker other  than
              the default.

              Alternate Options:

              None

       -dynamiclib (M*X only)

              Invokes   the   libtool   command   to  generate  dynamic
              libraries.

              Architecture  Restrictions:  Not available on Intel(R) 64
              architecture targeting Intel(R) MIC Architecture

              Arguments:

              None

              Default:

              OFF               The compiler produces an executable.

              Description:

              This  option  invokes  the  libtool  command  to generate
              dynamic libraries.

              When passed this option, the compiler  uses  the  libtool
              command  to  produce a dynamic library instead of an exe-
              cutable when linking.

              To build static  libraries,  you  should  specify  option
              -staticlib or libtool -static <objects>.

              Alternate Options:

              None
              Description:

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

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

              Alternate Options:

              None

       -early-template-check

       -no-early-template-check

              Lets you semantically check template
                     function template prototypes before instantiation.

              Arguments:

              None

              Default:

              -no-early-template-check
                                The prototype instantiation of function
                                templates and function members of class
                                templates is deferred.

              Description:

              Lets  you  semantically  check template function template
              prototypes before instantiation. On Linux* platforms, gcc
              3.4  (or newer) compatibilty modes must be in effect. For
              all OS X* platforms, gcc 4.0 (or newer) is required.

              Alternate Options:

              None

       -EP

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

              Arguments:

              tives) to a file instead of stdout.

              Alternate Options:

              None

       -Fdir (M*X only)

              Adds a framework directory to the head of an include file
              search path.

              Architecture Restrictions:  Not available on Intel(R)  64
              architecture targeting Intel(R) MIC Architecture

              Arguments:

              dir               Is the name for  the  framework  direc-
                                tory.

              Default:

              OFF               The  compiler  does not add a framework
                                directory to the  head  of  an  include
                                file search path.

              Description:

              This  option adds a framework directory to the head of an
              include file search path.

              Alternate Options:

              None

       -Fa[filename|dir]

              Specifies that an assembly listing file
                     should be generated.

              Arguments:

              filename          Is the name  of  the  assembly  listing
                                file.

              dir               Is  the directory where the file should
                                be placed.  It can include filename.

              Default:

              OFF               No assembly listing file is produced.

              Description:

              Arguments:

              n                 Is  the  ABI  implementation.  Possible
                                values are:

                                0              Requests the latest  ABI
                                               implementation.

                                1              Requests  the ABI imple-
                                               mentation  used  in  gcc
                                               3.2 and gcc 3.3.

                                2              Requests  the ABI imple-
                                               mentation  used  in  gcc
                                               3.4 and higher.

              Default:

              Varies            The  compiler  uses the ABI implementa-
                                tion that corresponds to the  installed
                                version of gcc.

              Description:

              This  option  tells the compiler to select a specific ABI
              implementation. This option is compatible with gcc option
              -fabi-version.  If  you  have  multiple  versions  of gcc
              installed, the compiler may change the value of n depend-
              ing on which gcc is detected in your path.

              NOTE:  gcc  3.2  and 3.3 are not fully ABI-compliant, but
              gcc 3.4 is highly ABI-compliant.

              CAUTION: Do not mix different values for -fabi-version in
              one link.

              Alternate Options:

              None

       -falias

       -fno-alias

              Determines whether aliasing is assumed in a
                     program.

              Arguments:

              None

              If you specify -falias, aliasing is assumed in a program.
              However, this may affect performance.

              Alternate Options:

              None

       -falign-functions[=n]

       -fno-align-functions

              Tells the compiler to align
                     functions on an optimal byte boundary.

              Arguments:

              n                 Is an optional  positive  integer  ini-
                                tialization  expression  indicating the
                                number of bytes for the minimum  align-
                                ment boundary. It tells the compiler to
                                align functions on  a  power-of-2  byte
                                boundary.  If you do not specify n, the
                                compiler aligns the start of  functions
                                on 16-byte boundaries.

                                The  n  must be a positive integer less
                                than or equal to 4096. If you specify a
                                value  that is not a power of 2, n will
                                be rounded up to the nearest  power  of
                                2.  For example, if 23 is specified for
                                n, functions will be aligned on 32 byte
                                boundaries.

              Default:

              -fno-align-functions
                                The compiler aligns functions on 2-byte
                                boundaries. This is the same as  speci-
                                fying  -falign-functions=2  (Linux* and
                                OS X*).

              Description:

              This option tells the compiler to align functions  on  an
              optimal  byte boundary. If you do not specify n, the com-
              piler aligns the start of  functions  on  16-byte  bound-
              aries.

              Alternate Options:

              None


                                If you specify 1 for n, no alignment is
                                performed; this is the same as specify-
                                ing the negative form of the option.

                                If  you  do  not specify n, the default
                                alignment is 16 bytes.

              Default:

              -fno-align-loops  or  /Qalign-loops-  No   special   loop
                                alignment is performed.

              Description:

              This option aligns loops to a power-of-two boundary. This
              alignment may improve performance.

              It can be affected by the pragma code_align and attribute
              code_align.

              If  code  is compiled with the -falign-loop=m (Linux* and
              OS  X*)  or  /Qalign-loop:m  (Windows*)  option   and   a
              code_align:n  pragma precedes a loop, the loop is aligned
              on a max (m, n) byte boundary. If a function is  modified
              by  a  code_align:k pragma and a code_align:n pragma pre-
              cedes a loop, then both the function  and  the  loop  are
              aligned on a max (k, n) byte boundary.

              Alternate Options:

              None

       -falign-stack=mode (L*X only)

              Tells the compiler the stack alignment to use on entry to
              routines.

              Architecture Restrictions: Only available on IA-32 archi-
              tecture

              Arguments:

              mode              Is  the  method to use for stack align-
                                ment.  Possible values are:

                                assume-4-byte  Tells  the  compiler  to
                                               assume   the   stack  is
                                               aligned on 4-byte bound-
                                               aries.  The compiler can
                                               dynamically  adjust  the
                                               stack  to 16-byte align-

                                assume-16-byte Tells  the  compiler  to
                                               assume   the   stack  is
                                               aligned    on    16-byte
                                               boundaries  and  to con-
                                               tinue    to     maintain
                                               16-byte  alignment. This
                                               setting  is   compatible
                                               with gcc.

              Default:

              -falign-stack=assume-16-byte
                                The   compiler  assumes  the  stack  is
                                aligned on 16-byte boundaries and  con-
                                tinues to maintain 16-byte alignment.

              Description:

              This option tells the compiler the stack alignment to use
              on entry to routines.

              Alternate Options:

              None

       -fargument-alias

       -fargument-noalias

              Determines whether  function  arguments  can  alias  each
              other.

              Arguments:

              None

              Default:

              -fargument-alias  Function arguments can alias each other
                                and can alias global storage.

              Description:

              This  option  determines  whether  function arguments can
              alias each other. If you  specify  -fargument-noalias  or
              /Qalias-args-,   function  arguments  cannot  alias  each
              other, but they can alias global storage.

              On Linux and OS X systems, you can also disable  aliasing
              for   global   storage,   by  specifying  option  -fargu-
              ment-noalias-global.

              Description:

              This  option  tells  the compiler that function arguments
              cannot alias each other  and  they  cannot  alias  global
              storage.

              If you only want to prevent function arguments from being
              able  to  alias  each  other,  specify   option   -fargu-
              ment-noalias.

              Alternate Options:

              None

       -fasm-blocks

              Enables  the use of blocks and entire functions of assem-
              bly 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  func-
              tions 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.

              On OS X* systems, this option is provided for compatibil-
              ity with the Apple* GNU compiler.

              Alternate Options:

              -use-msasm

       -fast

              Maximizes speed across the entire
                     program.

              Arguments:

              None
              systems: /O3, /Qipo, /Qprec-div-, /fp:fast=2, and /QxHost
              On  Linux*  systems:  -ipo,  -O3,  -no-prec-div, -static,
              -fp-model fast=2, and -xHost  On  Intel(R)  64  architec-
              ture-based  systems  targeting  the Intel(R) Xeon Phi(TM)
              coprocessor  x100  product  family  (formerly  code  name
              Knights  Corner):  [Q]ipo,  O3,  -no-prec-div (Linux*) or
              /Qprec-div-  (Windows*),  -fp-model  fast=2  (Linux*)  or
              /fp:fast=2 (Windows*)

              When  option  fast  is  specified,  you  can override the
              [Q]xHost option setting by specifying a different proces-
              sor-specific  [Q]x  option  on the command line. However,
              the last option  specified  on  the  command  line  takes
              precedence.

              For example:

              · On  Linux* systems, if you specify option -fast -xSSE3,
                option -xSSE3 takes effect.  However,  if  you  specify
                -xSSE3 -fast, option -xHost takes effect.

              · On  Windows*  systems,  if  you  specify  option  /fast
                /QxSSE3, option/QxSSE3 takes effect.  However,  if  you
                specify /QxSSE3 /fast, option /QxHost takes effect.

              For  implications  on  non-Intel processors, refer to the
              [Q]xHost documentation.

              NOTE: Option fast sets some aggressive optimizations that
              may  not be appropriate for all applications. The result-
              ing 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.


              Optimization Notice


              = = = = = = = = = =

              Intel's  compilers  may  or  may not optimize to the same
              degree for non-Intel  microprocessors  for  optimizations
              that are not unique to Intel microprocessors. These opti-
              mizations include SSE2, SSE3, and SSSE3 instruction  sets
              and  other  optimizations.  Intel  does not guarantee the
              availability,  functionality,  or  effectiveness  of  any
              optimization   on  microprocessors  not  manufactured  by
              Intel.  Microprocessor-dependent  optimizations  in  this
              product  are intended for use with Intel microprocessors.
              Certain optimizations not specific to  Intel  microarchi-
              tecture  are  reserved  for Intel microprocessors. Please

       -no-fast-transcendentals

              Enables the compiler to replace calls to
                     transcendental functions with faster but less pre-
                     cise implementations.

              Arguments:

              None

              Default:

              depends on the setting
                                of -fp-model (Linux* and OS X*) If  you
                                do  not specify option -[no-]fast-tran-
                                scendentals:

                                · The default is ON if option -fp-model
                                  fast is specified or is in effect.

                                · The  default  is  OFF if a value-safe
                                  setting is  specified  for  -fp-model
                                  (such  as "precise", "source", etc.).

              Description:

              This option enables the  compiler  to  replace  calls  to
              transcendental functions with implementations that may be
              faster but less precise.

              It allows the compiler to perform  certain  optimizations
              on transcendental functions, such as replacing individual
              calls to sine in a loop with a single call to a less pre-
              cise vectorized sine library routine.

              This  option  does  not affect explicit Short Vector Math
              Library (SVML) intrinsics. It only affects  scalar  calls
              to the standard math library routines.

              You  cannot use option –fast-transcendentals with option
              –fp-model strict.

              This option determines the setting for the maximum allow-
              able  relative  error  for  math library function results
              (max-error) if none of the following options  are  speci-
              fied:

              · -fimf-accuracy-bits  (Linux*  and OS X*) or /Qimf-accu-
                racy-bits (Windows*)

              · -fimf-max-error (Linux and  OS  X)  or  /Qimf-max-error
                (Windows)

              degree for non-Intel  microprocessors  for  optimizations
              that are not unique to Intel microprocessors. These opti-
              mizations include SSE2, SSE3, and SSSE3 instruction  sets
              and  other  optimizations.  Intel  does not guarantee the
              availability,  functionality,  or  effectiveness  of  any
              optimization   on  microprocessors  not  manufactured  by
              Intel.  Microprocessor-dependent  optimizations  in  this
              product  are intended for use with Intel microprocessors.
              Certain optimizations not specific to  Intel  microarchi-
              tecture  are  reserved  for Intel microprocessors. Please
              refer to the applicable product User and Reference Guides
              for  more  information regarding the specific instruction
              sets covered by this notice.

              Notice revision #20110804

              = = = = = = = = = =

              Alternate Options:

              None

       -fasynchronous-unwind-tables

       -fno-asynchronous-unwind-tables

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

              Arguments:

              None

              Default:

              Intel(R) 64 architecture: -fasynchronous-unwind-tables
                                The  unwind  table generated is precise
                                at  an instruction  boundary,  enabling
                                accurate  unwinding at any instruction.

              IA-32 architecture: -fno-asynchronous-unwind-tables
                                The unwind table generated  is  precise
                                at call boundaries only.

              Description:

              This option determines whether unwind information is pre-
              cise 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.

                that  does  not  contain  calls  to routines that might
                throw an exception.

              Alternate Options:

              None

       -fblocks (M*X only)

       -fno-blocks (M*X only)

              Determines whether Apple* blocks are enabled or disabled.

              Architecture Restrictions:  Not available on Intel(R)  64
              architecture targeting Intel(R) MIC Architecture

              Arguments:

              None

              Default:

              -fblocks          Apple* blocks are enabled.

              Description:

              This option determines whether Apple* blocks (block vari-
              able declarations) are enabled or disabled.

              If   you   want   to   disable   Apple*  blocks,  specify
              -fno-blocks.

              To use this feature, OS X* 10.6 or greater is required.

              Alternate Options:

              None

       -fbuiltin[-name]

       -fno-builtin[-name]

              Enables or disables inline expansion of  intrinsic  func-
              tions.

              Arguments:

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


              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

       -fcode-asm

              Produces an assembly listing with  machine  code  annota-
              tions.

              Arguments:

              None

              Default:

              OFF               No machine code annotations  appear  in
                                the  assembly  listing  file, if one is
                                produced.

              Description:

              This  option  produces  an  assembly  listing  file  with
              machine code annotations.

              The  assembly listing file shows the hex machine instruc-
              tions at the beginning of each line of assembly code. The
              file  cannot  be  assembled; the file name is the name of
              the source file with an extension of .cod.

              To use this option, you  must  also  specify  option  -S,
              which causes an assembly listing to be generated.

              Alternate Options:

              Linux and OS X: None

       -fcommon

       -fno-common

              Determines whether the compiler treats
                     common symbols as global definitions.


              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  mod-
              ule; 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 rep-
              resented 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

       -fdefer-pop

       -fno-defer-pop

              Determines whether the compiler always pops the arguments
              to each function call as soon as that function returns.

              Arguments:

              None

              Default:

              -fdefer-pop       The compiler uses default optimizations
                                that may result in  deferred  clearance
                                of the stack arguments.

              Description:

              This  option  determines whether the compiler always pops
              the arguments to each function call as soon as that func-
              tion returns.

              If  you  want the compiler to always pop the arguments to
              each function call as  soon  as  that  function  returns,
              specify -fno-defer-pop.

              For  processors  that must pop arguments after a function
              call, the compiler normally lets arguments accumulate  on
              the stack for several function calls and pops them all at
              once.

              Alternate Options:


              -feliminate-unused-debug-types
                                The compiler  emits  debug  information
                                only  for  types that are actually used
                                by a variable/parameter/etc..

              Description:

              This option controls the debug  information  emitted  for
              types declared in a compilation unit.

              If  you  specify -fno-eliminate-unused-debug-types (Linux
              and OS X)  or  /Qeliminate-unused-debug-types-,  it  will
              cause  the  compiler  to  emit  debug information for all
              types present in the sources. This  option  may  cause  a
              large increase in the size of the debug information.

              Alternate Options:

              None

       -femit-class-debug-always (L*X only)

       -fno-emit-class-debug-always (L*X only)

              Controls  the format and size of debug information gener-
              ated by the compiler for C++ classes.

              Arguments:

              None

              Default:

              -fno-emit-class-debug-always
                                Causes   the  compiler  to  reduce  the
                                amount of debug  information  generated
                                for C++ classes.

              Description:

              When  emission  of  debug  information  is  enabled, this
              option will control the format and size of debug informa-
              tion  generated by the compiler for C++ classes. It tells
              the compiler to generate full debug  information,  or  it
              tells the compiler to reduce the amount of debug informa-
              tion it generates.

              When you specify  the  -femit-class-debug-always  option,
              the compiler emits debug information for a C++ class into
              each object file where the class is used.  This option is
              useful  for tools that are not able to resolve incomplete
              None

       -fexceptions

       -fno-exceptions

              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

       -fextend-arguments=n

              Controls how scalar integer  arguments  are  extended  in
              calls to unprototyped and varargs functions.

              Arguments:

              n                 Specifies the extension for the integer
                                parameters. Possible values are:

                                32             Causes      unprototyped
                                               integer parameters to be
                                               extended to 32 bits.

                                64             Causes      unprototyped
                                               integer parameters to be
                                               extended   to  64  bits.
                                               This   value   is   only

              Alternate Options:

              None

       -ffat-lto-objects (L*X only)

       -fno-fat-lto-objects (L*X only)

              Determines  whether  a  fat  link-time optimization (LTO)
              object, containing both intermediate language and  object
              code, is generated during an interprocedural optimization
              compilation (-c –ipo).

              Architecture  Restrictions: Not available on IA-32 archi-
              tecture targeting Intel(R)  Graphics  Technology,  or  on
              Intel(R)  64  architecture  targeting  Intel(R)  Graphics
              Technology

              Arguments:

              None

              Default:

              -ffat-lto-objects When   –c –ipo is specified, the com-
                                piler generates a fat  link-time  opti-
                                mization  (LTO)  object that has both a
                                true object and a discardable  interme-
                                diate language section.

              Description:

              This  option determines whether a fat link time optimiza-
              tion (LTO) object, containing both intermediate  language
              and  object  code, is generated during an interprocedural
              optimization compilation (-c –ipo).

              During an interprocedural  optimization  compilation  (-c
              –ipo), the following occurs:

              · If  you  specify -ffat-lto-objects, the compiler gener-
                ates a fat link-time optimization (LTO) object that has
                both  a true object and a discardable intermediate lan-
                guage section.  This enables both  link-time  optimiza-
                tion (LTO) linking and normal linking.

              · If  you specify -fno-fat-lto-objects, the compiler gen-
                erates a fat link-time optimization (LTO)  object  that
                only  has  a discardable intermediate language section;
                no true object is generated. This  option  may  improve
                compilation time.


       -ffnalias

       -fno-fnalias

              Determines whether aliasing is assumed
                     within functions.

              Arguments:

              None

              Default:

              -ffnalias         Aliasing is assumed within functions.

              Description:

              This option determines whether aliasing is assumed within
              functions.

              If  you  specify  -fno-fnalias,  aliasing  is not assumed
              within functions, but it is assumed across calls.

              If you specify  -ffnalias,  aliasing  is  assumed  within
              functions.

              Alternate Options:

              None

       -ffreestanding

              Ensures  that  compilation  takes place in a freestanding
              environment.

              Arguments:

              None

              Default:

              OFF               Standard libraries are used during com-
                                pilation.

              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

       -fno-friend-injection

              Causes  the  compiler to inject friend functions into the
              enclosing namespace.

              Arguments:

              None

              Default:

              -fno-friend-injection
                                The  compiler  does  not  inject friend
                                functions into the enclosing namespace.
                                A  friend function that is not declared
                                in an enclosing scope can only be found
                                using argument-dependent lookup.

              Description:

              This  option  causes  the compiler to inject friend func-
              tions into the enclosing namespace, so they  are  visible
              outside  the  scope  of  the  class  in  which  they  are
              declared.

              On Linux systems,  in gcc versions 4.1 or later, this  is
              not  the default behavior. This option allows compatibil-
              ity with gcc 4.0 or earlier.

              Alternate Options:

              None

       -ffunction-sections

              Places each function in its own COMDAT section.

              Arguments:

              None

              Default:

              OFF

              Description:

              Places each function in its own COMDAT section.

              Alternate Options:


              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]

              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   abso-
                                lute-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.  Preci-
                                sion-specific  variants  like  sin  and
                                sinf  are  considered  different  func-
                                tions,  so  you  would  need   to   use
                                -fimf-absolute-error=0.00001:sin,sinf
                                (or                         /Qimf-abso-
                                lute-error:0.00001:sin,sinf) to specify
                                the maximum  allowable  absolute  error
                                for  both the single-precision and dou-
                                ble-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-abso-
                                lute-error=0.00001:/   or   /Qimf-abso-
                                lute-error: 0.00001:/.


              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 abso-
              lute-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  pre-
              cision,   you   can  specify  :sinf,  as  in  -fimf-abso-
              lute-error=0.00001:sin           or           /Qimf-abso-
              lute-error:0.00001:sin,           or          -fimf-abso-
              lute-error=0.00001:sqrtf          or          /Qimf-abso-
              lute-error:0.00001:sqrtf.

              If  you  do not specify any function names, then the set-
              ting 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  corre-
              sponding 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 opti-
              mized for Intel(R)  microprocessors  than  for  non-Intel
              microprocessors.


              Optimization Notice


              = = = = = = = = = =

              Intel's  compilers  may  or  may not optimize to the same
              degree for non-Intel  microprocessors  for  optimizations
              that are not unique to Intel microprocessors. These opti-
              mizations include SSE2, SSE3, and SSSE3 instruction  sets
              and  other  optimizations.  Intel  does not guarantee the
              availability,  functionality,  or  effectiveness  of  any
              optimization   on  microprocessors  not  manufactured  by
              Intel.  Microprocessor-dependent  optimizations  in  this
              product  are intended for use with Intel microprocessors.
              Certain optimizations not specific to  Intel  microarchi-
              tecture  are  reserved  for Intel microprocessors. Please
              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. Preci-
                                sion-specific  variants  like  sin  and
                                sinf  are  considered  different  func-
                                tions,  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:
                racy-bits:23:sinf,cosf,logf

              · -fimf-accuracy-bits=52:sqrt,/,trunc    or   /Qimf-accu-
                racy-bits:52:sqrt,/,trunc

              · -fimf-accuracy-bits=10:powf       or        /Qimf-accu-
                racy-bits:10:powf

              If  you  do not specify any function names, then the set-
              ting 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  corre-
              sponding 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  maxi-
              mum relative error.  They are as follows:

              · -fimf-precision  (Linux*  and OS X*) or /Qimf-precision
                (Windows*)

              · -fimf-max-error (Linux* and OS X*)  or  /Qimf-max-error
                (Windows*)

              · -fimf-accuracy-bits  (Linux  and  OS X*) or /Qimf-accu-
                racy-bits (Windows)

              If more than one of  these  options  are  specified,  the
              default  value  for  the maximum relative error is deter-
              mined 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:

              · [Q]fast-transcendentals

              · [Q]prec-div

              · [Q]prec-sqrt

              · -fp-model (Linux and OS X) or /fp (Windows)

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


              Optimization Notice
              tecture  are  reserved  for Intel microprocessors. Please
              refer to the applicable product User and Reference Guides
              for  more  information regarding the specific instruction
              sets covered by this notice.

              Notice revision #20110804

              = = = = = = = = = =

              Alternate Options:

              None

       -fimf-arch-consistency=value[:funclist]

              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.  Preci-
                                sion-specific  variants  like  sin  and
                                sinf  are  considered  different  func-
                                tions,   so   you  would  need  to  use
                                -fimf-arch-consistency=true:sin,sinf
                                (or                  /Qimf-arch-consis-
                                tency:true:sin,sinf) to specify consis-
                                tent results for both the single-preci-
                                sion and  double-precision  sine  func-
                                tions.

                                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-consis-
                                tency=true:/   or    /Qimf-arch-consis-
                                tency:true:/.

              Default:

              is  not guaranteed across IA-32 architecture and Intel(R)
              64 architecture.

              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 pre-
              cision, you can specify :sinf, as  in  -fimf-arch-consis-
              tency=true:sin   or  /Qimf-arch-consistency:true:sin,  or
              -fimf-arch-consistency=false:sqrtf or  /Qimf-arch-consis-
              tency:false:sqrtf.

              If  you  do not specify any function names, then the set-
              ting 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  corre-
              sponding 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  OS   X*)   and
              /Qimf-arch-consistency  (Windows*)  option  may  decrease
              run-time  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,  for
              example,  between IA-32 and Intel(R) 64 architectures, or
              between Intel(R) 64 architecture and Intel(R) MIC  Archi-
              tecture.

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


              Optimization Notice


              = = = = = = = = = =

              Intel's compilers may or may not  optimize  to  the  same
              degree  for  non-Intel  microprocessors for optimizations
              that are not unique to Intel microprocessors. These opti-
              mizations  include SSE2, SSE3, and SSSE3 instruction sets
              and other optimizations. Intel  does  not  guarantee  the
              availability,  functionality,  or  effectiveness  of  any
              optimization  on  microprocessors  not  manufactured   by
              Intel.  Microprocessor-dependent  optimizations  in  this
              product are intended for use with Intel  microprocessors.

       -fimf-domain-exclusion=classlist[:funclist]

              Indicates the input arguments domain on which math  func-
              tions must provide correct results.

              Arguments:

              classlist         Is one of the following:

                                · One or more of the  following  float-
                                  ing-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 func-
                                  tion.   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   corre-
                                                  sponds  to  the class

                                  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.   Preci-
                                sion-specific  variants  like  sin  and
                                sinf  are  considered  different  func-
                                tions,   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  sin-
                                gle-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-exclu-
                                sion=23:log,logf,/,sin,cosf          or
                                /Qimf-domain-exclu-
                                sion:23:log,logf,/,sin,cosf

                                If  you  don ’t  specify argument fun-
                                clist, the domain restrictions apply to
                                all math library functions.

              Default:

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

              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 pre-
              cision, you can specify :sinf, as in  -fimf-domain-exclu-
              sion=denormals:sin     or   /Qimf-domain-exclusion:denor-
              mals:sin,  or  -fimf-domain-exclusion=extremes:sqrtf   or
              /Qimf domain-exclusion:extremes:sqrtf.

              If  you  do not specify any function names, then the set-
              ting 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  corre-
              sponding 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 opti-
              mized for Intel(R)  microprocessors  than  for  non-Intel
              microprocessors.


              Optimization Notice


              = = = = = = = = = =

              Intel's  compilers  may  or  may not optimize to the same
              degree for non-Intel  microprocessors  for  optimizations
              that are not unique to Intel microprocessors. These opti-
              mizations include SSE2, SSE3, and SSSE3 instruction  sets
              and  other  optimizations.  Intel  does not guarantee the
              availability,  functionality,  or  effectiveness  of  any
              optimization   on  microprocessors  not  manufactured  by
              Intel.  Microprocessor-dependent  optimizations  in  this
              product  are intended for use with Intel microprocessors.
              Certain optimizations not specific to  Intel  microarchi-
              tecture  are  reserved  for Intel microprocessors. Please
              refer to the applicable product User and Reference Guides
              for  more  information regarding the specific instruction
              sets covered by this notice.

              Notice revision #20110804

              = = = = = = = = = =

              Alternate Options:

              None

       -fimf-max-error=ulps[:funclist]
              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. Preci-
                                sion-specific  variants  like  sin  and
                                sinf  are  considered  different  func-
                                tions,  so  you  would  need   to   use
                                -fimf-max-error=4.0:sin,sinf        (or
                                /Qimf-max-error=4.0:sin,sinf) to  spec-
                                ify   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 run-time performance and the accu-
              racy 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 pre-
              cision,    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  set-
              ting  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 corre-
              · -fimf-accuracy-bits (Linux and OS  X*)  or  /Qimf-accu-
                racy-bits (Windows)

              If  more  than  one  of  these options are specified, the
              default value for the maximum relative  error  is  deter-
              mined 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:

              · [Q]fast-transcendentals

              · [Q]prec-div

              · [Q]prec-sqrt

              · -fp-model (Linux and OS X) or /fp (Windows)

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


              Optimization Notice


              = = = = = = = = = =

              Intel's compilers may or may not  optimize  to  the  same
              degree  for  non-Intel  microprocessors for optimizations
              that are not unique to Intel microprocessors. These opti-
              mizations  include SSE2, SSE3, and SSSE3 instruction sets
              and other optimizations. Intel  does  not  guarantee  the
              availability,  functionality,  or  effectiveness  of  any
              optimization  on  microprocessors  not  manufactured   by
              Intel.  Microprocessor-dependent  optimizations  in  this
              product are intended for use with Intel  microprocessors.
              Certain  optimizations  not specific to Intel microarchi-
              tecture are reserved for  Intel  microprocessors.  Please
              refer to the applicable product User and Reference Guides
              for more information regarding the  specific  instruction
              sets covered by this notice.

              Notice revision #20110804

              = = = = = = = = = =

              Alternate Options:

              None

                                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   func-
                                               tions;  accuracy-bits  =
                                               26  for double-precision
                                               functions.

                                In the  above  explanations,  max-error
                                means  option  -fimf-max-error  (Linux*
                                and OS  X*)  or  /Qimf-max-error  (Win-
                                dows*);   accuracy-bits   means  option
                                -fimf-accuracy-bits (Linux* and OS  X*)
                                or /Qimf-accuracy-bits (Windows*).

              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. Preci-
                                sion-specific  variants  like  sin  and
                                sinf  are  considered  different  func-
                                tions,  so  you  would  need   to   use
                                -fimf-precision=high:sin,sinf       (or
                                /Qimf-precision:high:sin,sinf) to spec-
                                ify  high  precision  for both the sin-
                                gle-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-preci-
                                sion=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  preci-
                                sion; see below for details.


              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 pre-
              cision,  you  can  specify  :sinf,  as  in   -fimf-preci-
              sion=low:sin  or /Qimf-precision:low:sin, or -fimf-preci-
              sion=high:sqrtf or /Qimf-precision:high:sqrtf.

              If you do not specify any function names, then  the  set-
              ting  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 corre-
              sponding 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 maxi-
              mum relative error.  They are as follows:

              · -fimf-precision (Linux* and OS X*)  or  /Qimf-precision
                (Windows*)

              · -fimf-max-error  (Linux*  and OS X*) or /Qimf-max-error
                (Windows*)

              · -fimf-accuracy-bits (Linux and OS  X*)  or  /Qimf-accu-
                racy-bits (Windows)

              If  more  than  one  of  these options are specified, the
              default value for the maximum relative  error  is  deter-
              mined 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:

              · [Q]fast-transcendentals

              · [Q]prec-div

              · [Q]prec-sqrt

              · -fp-model (Linux and OS X) or /fp (Windows)

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


              Certain  optimizations  not specific to Intel microarchi-
              tecture are reserved for  Intel  microprocessors.  Please
              refer to the applicable product User and Reference Guides
              for more information regarding the  specific  instruction
              sets covered by this notice.

              Notice revision #20110804

              = = = = = = = = = =

              Alternate Options:

              None

       -finline

       -fno-inline

              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:

              Linux and OS X: -inline-level

       -finline-functions

       -fno-inline-functions

              Enables function inlining for single file compilation.

              Arguments:

              None

              Default:

              -finline-functions
              expansion. To specify the size  of  the  function  to  be
              expanded, use the -finline-limit option.

              Alternate Options:

              Linux and OS X: -inline-level=2

       -finline-limit=n

              Lets  you  specify  the  maximum size of a function to be
              inlined.

              Arguments:

              n                 Must  be  an  integer  greater  than or
                                equal to zero. It is the maximum number
                                of  lines  the  function can have to be
                                considered for inlining.

              Default:

              OFF               The compiler  uses  default  heuristics
                                when inlining functions.

              Description:

              This  option lets you specify the maximum size of a func-
              tion to be inlined. The compiler  inlines  smaller  func-
              tions,  but  this option lets you inline large functions.
              For example, to indicate  a  large  function,  you  could
              specify 100 or 1000 for n.

              Note  that  parts  of  functions  cannot be inlined, only
              whole functions.

              This option is a modification of  the  -finline-functions
              option, whose behavior occurs by default.

              Alternate Options:

              None

       -finstrument-functions

       -fno-instrument-functions

              Determines whether
                     function entry and exit points are instrumented.

              Architecture  Restrictions: Not available on IA-32 archi-
              tecture targeting Intel(R)
                     Graphics  Technology,  or on Intel(R) 64 architec-

              This  option  determines  whether function entry and exit
              points are instrumented. It may increase execution  time.

              The  following  profiling  functions  are called with the
              address of the current function and the address of  where
              the function was called (its "call site"):

              · This function is called upon function entry:

                ·

                  void __cyg_profile_func_enter (void *this_fn,

                  void *call_site);

              · This function is called upon function exit:

                ·

                  void __cyg_profile_func_exit (void *this_fn,

                  void *call_site);

              These  functions  can be used to gather more information,
              such as profiling information or timing information. Note
              that  it  is  the  user's responsibility to provide these
              profiling functions.

              If you specify -finstrument-functions (Linux* and OS  X*)
              or  /Qinstrument-functions  (Windows*), function inlining
              is disabled. If you specify -fno-instrument-functions  or
              /Qinstrument-functions-, inlining is not disabled.

              On  Linux  and  OS  X  systems, you can use the following
              attribute to  stop  an  individual  function  from  being
              instrumented:

              __attribute__((__no_instrument_function__))


              It also stops inlining from being disabled for that indi-
              vidual function.

              This option is provided for compatibility with gcc.

              Alternate Options:

              None

       -fjump-tables

       -fno-jump-tables

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

              Option -fno-jump-tables prevents the compiler from gener-
              ating  jump  tables for switch statements. This action is
              performed unconditionally and independent of  any  gener-
              ated 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 reloca-
              tion cannot be resolved.

              Alternate Options:

              None

       -fkeep-static-consts

       -fno-keep-static-consts

              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* and OS X*).

              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

              -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*  and OS X*), 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  instruc-
              tions  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 and OS
              X), or /arch (Windows).

       -fmath-errno

       -fno-math-errno

              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
              ing-point constants) across compilation units.

              Arguments:

              None

              Default:

              -fmerge-constants The  compiler  and  linker  attempt  to
                                merge identical constants across compi-
                                lation units if the compiler and linker
                                supports it.

              Description:

              This  option  determines  whether the compiler and linker
              attempt to merge identical  constants  (string  constants
              and floating-point constants) across compilation units.

              If  you do not want the compiler and linker to attempt to
              merge  identical  constants  across  compilation   units.
              specify -fno-merge-constants.

              Alternate Options:

              None

       -fmerge-debug-strings (L*X only)

       -fno-merge-debug-strings (L*X only)

              Causes  the  compiler  to  pool strings used in debugging
              information.

              Arguments:

              None

              Default:

              -fmerge-debug-strings
                                The  compiler will pool strings used in
                                debugging information.

              Description:

              This option causes the compiler to pool strings  used  in
              debugging  information.  The  linker  will  automatically
              retain this pooling.

              This option can reduce the size of debug information, but
              it may produce slightly slower compile and link times.

       -fminshared

              Specifies that a compilation unit is a
                     component of a main  program  and  should  not  be
                     linked as part of a shareable object.

              Architecture  Restrictions:  Not available on Intel(R) 64
              architecture targeting the
                     Intel(R)  Xeon  Phi(TM)  coprocessor  x100 product
                     family (formerly code name Knights Corner)

              Arguments:

              None

              Default:

              OFF               Source files are compiled  together  to
                                form a single object file.

              Description:

              This option specifies that a compilation unit is a compo-
              nent of a main program and should not be linked  as  part
              of a shareable object.

              This option allows the compiler to optimize references to
              defined symbols without special visibility  settings.  To
              ensure  that  external  and  common symbol references are
              optimized, you need to specify visibility hidden or  pro-
              tected by using the -fvisibility, -fvisibility-hidden, or
              -fvisibility-protected option.

              Also, the  compiler  does  not  need  to  generate  posi-
              tion-independent  code  for  the main program. It can use
              absolute addressing, which may reduce  the  size  of  the
              global  offset table (GOT) and may reduce memory traffic.

              Alternate Options:

              None

       -fmpc-privatize (L*X only)

       -fno-mpc-privatize (L*X only)

              Enables or disables privatization of all
                     static data for the MultiProcessor Computing envi-
                     ronment (MPC) unified parallel runtime.

              Architecture  Restrictions: Only available on Intel(R) 64
              architecture
              This  option  enables  or  disables  privatization of all
              static data for the MultiProcessor Computing  environment
              (MPC) unified parallel runtime.

              Option   -fmpc-privatize   causes   calls   to   extended
              thread-local-storage (TLS) resolution, run-time  routines
              that  are not supported on standard Linux* distributions.

              This option requires  installation  of  another  product.
              For more information, see Feature Requirements.

              Alternate Options:

              None

       -fms-dialect[=ver] (L*X only)

              Enables support for a language dialect
                     that  is compatible with Microsoft* Windows, while
                     maintaining link compatibility with gcc.

              Arguments:

              ver               Indicates  that  the  language  dialect
                                should  be  compatible  with  a certain
                                version of  Microsoft*  Visual  Studio.
                                Possible values are:

                                14             Specifies   the  dialect
                                               should   be   compatible
                                               with  Microsoft*  Visual
                                               Studio 2015.

                                12             Specifies  the   dialect
                                               should   be   compatible
                                               with  Microsoft*  Visual
                                               Studio 2013.

                                11             Specifies   the  dialect
                                               should   be   compatible
                                               with  Microsoft*  Visual
                                               Studio 2012. This is the
                                               default  if  you  do not
                                               specify ver.

                                10             Specifies  the   dialect
                                               should   be   compatible
                                               with  Microsoft*  Visual
                                               Studio  2010.  This is a
                                               deprecated option.

              Default:

              Linux and OS X: None

       -fmudflap (L*X only)

              The compiler instruments risky pointer
                     operations to prevent buffer overflows and invalid
                     heap use. This is a deprecated option. There is no
                     replacement option. You  can  consider  using  the
                     Pointer    Checker   options   (such   as   option
                     -check-pointers).

              Architecture Restrictions:  Not available on Intel(R)  64
              architecture targeting the
                     Intel(R) Xeon  Phi(TM)  coprocessor  x100  product
                     family (formerly code name Knights Corner)

              Arguments:

              None

              Default:

              OFF               The  compiler does not instrument risky
                                pointer operations.

              Description:

              The compiler instruments risky pointer operations to pre-
              vent  buffer  overflows and invalid heap use. It requires
              gcc 4.0 or newer.

              When using this compiler option, you must specify  linker
              option -lmudflap in the link command line to resolve ref-
              erences to the libmudflap library.

              Alternate Options:

              None

       -fno-gnu-keywords

              Tells the compiler to not recognize typeof as a  keyword.

              Arguments:

              None

              Default:

              OFF               Keyword typeof is recognized.


              None

              Default:

              OFF               The  compiler  handles  inlines so that
                                compilations, with  and  without  opti-
                                mization,  will  need  the  same set of
                                explicit instantiations.

              Description:

              This option tells the  compiler  to  not  emit  code  for
              implicit instantiations of inline templates.

              Alternate Options:

              None

       -fno-implicit-templates

              Tells  the  compiler to not emit code for non-inline tem-
              plates that are instantiated implicitly.

              Arguments:

              None

              Default:

              OFF               The  compiler  handles  inlines so that
                                compilations, with  and  without  opti-
                                mization,  will  need  the  same set of
                                explicit instantiations.

              Description:

              This option tells the  compiler  to  not  emit  code  for
              non-inline  templates  that  are instantiated implicitly,
              but to only emit code for explicit instantiations.

              Alternate Options:

              None

       -fnon-call-exceptions

       -fno-non-call-exceptions

              Allows trapping instructions to throw C++ exceptions.

              Arguments:
              caught using the standard C++ exception  handling  mecha-
              nism. Examples of such signals are SIGFPE (floating-point
              exception) and SIGSEGV (segmentation violation).

              You must write a signal handler that catches  the  signal
              and throws a C++ exception. After that, any occurrence of
              that signal within a C++ try block can be caught by a C++
              catch  handler  of  the  same  type  as the C++ exception
              thrown within the signal handler.

              Only signals generated by trapping instructions (that is,
              memory  access  instructions  and floating-point instruc-
              tions) can be caught. Signals that can occur at any time,
              such as SIGALRM, cannot be caught in this manner.

              Alternate Options:

              None

       -fnon-lvalue-assign

       -fno-non-lvalue-assign

              Determines  whether casts and conditional expressions can
              be used as lvalues.

              Arguments:

              None

              Default:

              -fnon-lvalue-assign
                                The  compiler  allows  casts and condi-
                                tional expressions to be used as  lval-
                                ues.

              Description:

              This  option  determines  whether  casts  and conditional
              expressions can be used as lvalues.

              Alternate Options:

              None

       -fno-operator-names

              Disables support for the operator names specified in  the
              standard.

              Arguments:
              None

       -fno-rtti

              Disables support for run-time type
                     information (RTTI).

              Arguments:

              None

              Default:

              OFF               Support  for  run-time type information
                                (RTTI) is enabled.

              Description:

              This option disables support for run-time  type  informa-
              tion (RTTI).

              Alternate Options:

              None

       -fomit-frame-pointer

       -fno-omit-frame-pointer

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

              Architecture Restrictions: Option
                     /Oy[-] is only available on IA-32 architecture

              Arguments:

              None

              Default:

              -fomit-frame-pointer
                                EBP is used as a general-purpose regis-
                                ter  in  optimizations.   However,   on
                                Linux*  and  OS X* systems, the default
                                is  -fno-omit-frame-pointer  if  option
                                -O0 or -g is specified.

              Description:

              These  options  determine  whether  EBP is used as a gen-
              eral-purpose   register   in    optimizations.    Options
              · For /Oy-: turning off /O1, /O2, or /O3 optimizations

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

              The  /Oy  option is set when you specify the /O1, /O2, or
              /O3 option. Option /Oy- is set when you specify  the  /Od
              option.

              Using  the -fno-omit-frame-pointer or /Oy- option reduces
              the number of available general-purpose registers  by  1,
              and can result in slightly less efficient code.

              NOTE: For Linux* systems:

              There  is  currently an issue with GCC 3.2 exception han-
              dling. Therefore, the Intel compiler ignores this  option
              when  GCC 3.2 is installed for C++ and exception handling
              is turned on (the default).

              Alternate Options:

              Linux and OS X: -fp (this is a deprecated option)

       -foptimize-sibling-calls

       -fno-optimize-sibling-calls

              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
              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[=1|2]     Enables  more aggressive
                                               optimizations on  float-
                                               ing-point data.

                                consistent     Enables      consistent,
                                               reproducible results for
                                               different   optimization
                                               levels or  between  dif-
                                               ferent processors of the
                                               same architecture.

                                strict         Enables   precise    and
                                               except,   disables  con-
                                               tractions,  and  enables
                                               pragma stdc fenv_access.

                                source         Rounds      intermediate
                                               results               to
                                               source-defined    preci-
                                               sion.

                                double         Rounds      intermediate
                                               results to 53-bit  (dou-
                                               ble) precision.

                                extended       Rounds      intermediate
                                               results    to     64-bit
                                               (extended) precision.

                                [no-]except    (Linux*  and  OS  X*) or
                                               except[-]  (Windows*   )
                                               Determines       whether
                                               strict    floating-point
                                               exception  semantics are
                                               honored.

              Default:

              -fp-model fast=1  The compiler uses more aggressive opti-
                                mizations  on  floating-point  calcula-

              You can use more than one keyword. However, the following
              rules apply:

              · You cannot specify fast and except together in the same
                compilation.  You  can specify any other combination of
                group A, group B,  and  group  C.  Since  fast  is  the
                default,  you must not specify except without a group A
                or group B keyword.

              · You should specify only one keyword from  group  A  and
                only  one  keyword  from group B. If you try to specify
                more than one keyword from either group A or  group  B,
                the last (rightmost) one takes effect.

              · If  you specify except more than once, the last (right-
                most) one takes effect.

              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 con-
              trols, 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 optimiza-
                                tions when implementing  floating-point
                                calculations. It disables optimizations
                                that can change the  result  of  float-
                                ing-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_DETERMINIS-
                                TIC_REDUCTION environment variable. For
                                more information about this environment
                                variable, see topic "Supported Environ-
                                ment Variables".


              Floating-point exception semantics are disabled
                                by default. To enable these  semantics,
                                you  must also specify -fp-model except
                                or /fp:except.

              -fp-model fast[=1|2] or
                                /fp:fast[=1|2] Tells  the  compiler  to
                                use  more aggressive optimizations when
                                implementing  floating-point   calcula-
                                tions.   These  optimizations  increase
                                speed, but may affect the  accuracy  or
                                reproducibility  of floating-point com-
                                putations.

              Specifying fast is the same as specifying
                                fast=1.  fast=2 may produce faster  and
                                less accurate results.

              Floating-point exception semantics are disabled
                                by  default  and they cannot be enabled
                                because you  cannot  specify  fast  and
                                except  together  in  the same compila-
                                tion. To  enable  exception  semantics,
                                you  must  explicitly  specify  another
                                keyword (see other keyword descriptions
                                for details).

              To enable exception semantics,
                                you  must  explicitly  specify  another
                                keyword (see other keyword descriptions
                                for details).

              -fp-model consistent or
                                /fp:consistent  Tells  the  compiler to
                                generate code that  will  give  consis-
                                tent,    reproducible    floating-point
                                results for different optimization lev-
                                els  or between different processors of
                                the same architecture .

              For more information, see the article titled: Consistency
                                of  Floating-Point  Results  using  the
                                Intel(R)  Compiler, which is located in
                                http://software.intel.com/en-us/arti-
                                cles/consistency-of-float-
                                ing-point-results-using-the-intel-com-
                                piler/

              -fp-model strict or
                                /fp:strict   Tells   the   compiler  to
                                strictly adhere to value-safe optimiza-
                                /fp:source This option causes  interme-
                                diate results to be rounded to the pre-
                                cision defined in the source  code.  It
                                also  implies keyword precise unless it
                                is overridden by a keyword  from  Group
                                A.

              Intermediate      expressions  use  the  precision of the
                                operand with higher precision, if  any.

              long double: 64-bit
                                precision;  80-bit  data  type;  15-bit
                                exponent

              double: 53-bit    precision;  64-bit  data  type;  11-bit
                                exponent;   on  Windows  systems  using
                                IA-32 architecture, the exponent may be
                                15-bit  if  an  x87 register is used to
                                hold the value.

              float: 24-bit     precision;  32-bit  data  type;   8-bit
                                exponent

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

              -fp-model double or
                                /fp:double This option causes  interme-
                                diate results to be rounded as follows:

              53-bit (double)   precision

              64-bit data type

              11-bit exponent; on
                                Windows systems using  IA-32  architec-
                                ture,  the exponent may be 15-bit if an
                                x87 register is used to hold the value.

              This option also implies keyword
                                precise  unless  it  is overridden by a
                                keyword from Group A.

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

              -fp-model extended or
                                /fp:extended  This option causes inter-
                                mediate results to be rounded  as  fol-
                                lows:

              -fp-model except or
                                /fp:except Tells the compiler to follow
                                strict floating-point exception  seman-
                                tics.

              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* and OS X*)  or  /Qimf-accu-
                racy-bits (Windows*)

              · -fimf-max-error  (Linux  and  OS  X) or /Qimf-max-error
                (Windows)

              · -fimf-precision (Linux and  OS  X)  or  /Qimf-precision
                (Windows)

              · [Q]fast-transcendentals

              Option   -fp-model   fast   (and  /fp:fast)  sets  option
              -fimf-precision=medium    (/Qimf-precision:medium)    and
              option   -fp-model   precise  (and  /fp:precise)  implies
              -fimf-precision=high (and  /Qimf-precision:high).  Option
              -fp-model fast=2 (and /fp:fast2) sets option -fimf-preci-
              sion=medium  (and  /Qimf-precision:medium)   and   option
              -fimf-domain-exclusion=15     (and    /Qimf-domain-exclu-
              sion=15).


              Optimization Notice


              = = = = = = = = = =

              Intel's compilers may or may not  optimize  to  the  same
              degree  for  non-Intel  microprocessors for optimizations
              that are not unique to Intel microprocessors. These opti-
              mizations  include SSE2, SSE3, and SSSE3 instruction sets
              and other optimizations. Intel  does  not  guarantee  the
              availability,  functionality,  or  effectiveness  of  any
              optimization  on  microprocessors  not  manufactured   by
              Intel.  Microprocessor-dependent  optimizations  in  this
              product are intended for use with Intel  microprocessors.
              Certain  optimizations  not specific to Intel microarchi-
              tecture are reserved for  Intel  microprocessors.  Please
              refer to the applicable product User and Reference Guides
              for more information regarding the  specific  instruction
              sets covered by this notice.


              Arguments:

              None

              Default:

              -no-fp-port       The default rounding  behavior  depends
                                on the compiler's code generation deci-
                                sions and the precision  parameters  of
                                the operating system.

              Description:

              This  option  rounds  floating-point results after float-
              ing-point operations.

              This option is  designed  to  be  used  with  the  -mia32
              (Linux*  and  OS X*) or /arch:IA32 (Windows*) option on a
              32-bit compiler. Under  those  conditions,  the  compiler
              implements  floating-point  calculations  using  the  x87
              instruction set, which uses an  internal  precision  that
              may  be  higher  than the precision specified in the pro-
              gram.

              By default, the  compiler  may  keep  results  of  float-
              ing-point  operations  in this higher internal precision.
              Rounding  to  program  precision  occurs  at  unspecified
              points.  This provides better performance, but the float-
              ing-point results are less deterministic. The  [Q]fp-port
              option  rounds  floating-point  results to user-specified
              precision at assignments and type conversions.  This  has
              some impact on speed.

              When  compiling  for  newer  architectures,  the compiler
              implements  floating-point  calculations  with  different
              instructions,  such  as  Intel(R)  SSE  and  SSE2.  These
              Intel(R) Streaming SIMD Extensions round directly to sin-
              gle  precision  or double precision at every instruction.
              In these cases, option [Q]fp-port has no effect.

              Alternate Options:

              None

       -fp-speculation=mode

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

              Arguments:

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

                                off            This   is  the  same  as
                                               specifying strict.

              Default:

              -fp-speculation=fast
                                The  compiler  speculates   on   float-
                                ing-point  operations. This is also the
                                behavior   when    optimizations    are
                                enabled.  However,  if  you  specify no
                                optimizations  (-O0  on  Linux*),   the
                                default     is     -fp-speculation=safe
                                (Linux*).

              Description:

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

              Disabling  speculation  may  prevent the vectorization of
              some loops containing conditionals. For an  example,  see
              the  article  titled: Diagnostic 15326: loop was not vec-
              torized: implied FP exception model  prevents  vectoriza-
              tion,     which     is     located    in    https://soft-
              ware.intel.com/en-us/articles/fdiag15326 .

              Alternate Options:

              None

       -fp-stack-check

              Tells the compiler to generate extra code
                     after every  function  call  to  ensure  that  the
                     floating-point stack is in the expected state.

              Arguments:

              None

              Default:

              OFF               There is no checking to ensure that the
                                floating-point (FP)  stack  is  in  the
                                expected state.

              Description:

              None

       -fp-trap=mode[,mode,...]

              Sets the floating-point trapping mode for
                     the main routine.

              Architecture  Restrictions:  Not available on Intel(R) 64
              architecture targeting the
                     Intel(R)  Xeon  Phi(TM)  coprocessor  x100 product
                     family (formerly code  name  Knights  Corner),  on
                     IA-32  architecture  targeting  Intel(R)  Graphics
                     Technology, or on Intel(R) 64 architecture target-
                     ing Intel(R) Graphics Technology

              Arguments:

              mode              Is the floating-point trapping mode. If
                                you specify more than one  mode  value,
                                the list is processed sequentially from
                                left to right. Possible values are:

                                [no]divzero    Enables or disables  the
                                               IEEE  trap  for division
                                               by zero.

                                [no]inexact    Enables or disables  the
                                               IEEE  trap  for  inexact
                                               result.

                                [no]invalid    Enables or disables  the
                                               IEEE  trap  for  invalid
                                               operation.

                                [no]overflow   Enables or disables  the
                                               IEEE  trap for overflow.

                                [no]underflow  Enables or disables  the
                                               IEEE trap for underflow.

                                [no]denormal   Enables or disables  the
                                               trap for denormal.

                                all            Enables all of the above
                                               traps.

                                none           Disables  all   of   the
                                               above traps.

                                common         Sets  the  most commonly
                                               used IEEE  traps:  divi-

              The [no] form of a mode value is only used to modify  the
              meaning  of  mode  values all and common, and can only be
              used with one of those  values.  The  [no]  form  of  the
              option  by  itself does not explicitly cause a particular
              trap to be disabled.

              Use mode value inexact with caution. This results in  the
              trap being enabled whenever a floating-point value cannot
              be  represented  exactly,  which  can  cause   unexpected
              results.

              If  mode  value  underflow  is  specified,  the  compiler
              ignores the FTZ (flush-to-zero)  bit  state  of  Intel(R)
              Streaming  SIMD  Extensions (Intel(R) SSE) floating-point
              units.

              When a DAZ (denormals are zero) bit is set in an Intel(R)
              SSE  floating-point unit control word, a denormal operand
              exception is never generated.

              To set the floating-point trapping mode for all routines,
              specify the[Q]fp-trap-all option.

              NOTE:  The negative form of the [Q]ftz option can be used
              to set or reset the FTZ and the DAZ hardware flags.

              Alternate Options:

              None

       -fp-trap-all=mode[,mode,...]

              Sets the floating-point trapping mode for
                     all routines.

              Architecture Restrictions: Not available on  Intel(R)  64
              architecture targeting the
                     Intel(R) Xeon  Phi(TM)  coprocessor  x100  product
                     family  (formerly  code  name  Knights Corner), on
                     IA-32  architecture  targeting  Intel(R)  Graphics
                     Technology, or on Intel(R) 64 architecture target-
                     ing Intel(R) Graphics Technology

              Arguments:

              mode              Is the floating-point trapping mode. If
                                you  specify  more than one mode value,
                                the list is processed sequentially from
                                left to right. Possible values are:

                                [no]divzero    Enables  or disables the
                                               IEEE trap  for  division
                                               IEEE trap for underflow.

                                [no]denormal   Enables  or disables the
                                               trap for denormal.

                                all            Enables all of the above
                                               traps.

                                none           Disables   all   of  the
                                               above traps.

                                common         Sets the  most  commonly
                                               used  IEEE  traps: divi-
                                               sion  by  zero,  invalid
                                               operation, and overflow.

              Default:

              -fp-trap-all=none No traps are enabled for all  routines.

              Description:

              This option sets the floating-point trapping mode for the
              main routine. It  does  not  set  a  handler  for  float-
              ing-point exceptions.

              The  [no] form of a mode value is only used to modify the
              meaning of mode values all and common, and  can  only  be
              used  with  one  of  those  values.  The [no] form of the
              option by itself does not explicitly cause  a  particular
              trap to be disabled.

              Use  mode value inexact with caution. This results in the
              trap being enabled whenever a floating-point value cannot
              be   represented  exactly,  which  can  cause  unexpected
              results.

              If  mode  value  underflow  is  specified,  the  compiler
              ignores  the  FTZ  (flush-to-zero)  bit state of Intel(R)
              Streaming SIMD Extensions (Intel(R)  SSE)  floating-point
              units.

              When a DAZ (denormals are zero) bit is set in an Intel(R)
              SSE floating-point unit control word, a denormal  operand
              exception is never generated.

              To set the floating-point trapping mode for the main rou-
              tine only, specify the [Q]fp-trap option.

              NOTE: The negative form of the [Q]ftz option can be  used
              to set or reset the FTZ and the DAZ hardware flags.


              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 and OS X: -Zp1

       -fpermissive

              Tells the compiler to allow for non-conformant code.

              Arguments:

              None

              Default:

              OFF

              Description:

              Tells the compiler to allow for non-conformant code.

              Alternate Options:

              None

       -fpic

       -fno-pic

              Determines  whether the compiler generates position-inde-
              pendent code.

              Arguments:

              None

              Default:

              -fno-pic          The  compiler  does  not generate posi-
                                tion-independent code.

              Description:

              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  posi-
                                tion-independent   code   for  an  exe-
                                cutable-only object.

              Description:

              This option tells the compiler to generate position-inde-
              pendent  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 refer-
              ences.

              To ensure that run-time 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

       -fprotect-parens

       -fno-protect-parens

              Determines whether the optimizer honors
                     parentheses when expressions are evaluated.

              Arguments:

              None

              Default:

              -fno-protect-parens
              When the option -fno-protect-parens (Linux* and OS X*) or
              /Qprotect-parens- (Windows*) is specified, the  optimizer
              may reorder expressions without regard for parentheses if
              it produces faster executing code.

              Alternate Options:

              None

       -freg-struct-return

              Tells the compiler to return struct and union  values  in
              registers when possible.

              Architecture Restrictions: Only available on IA-32 archi-
              tecture

              Arguments:

              None

              Default:

              OFF

              Description:

              This option tells the compiler to return struct and union
              values in registers when possible.

              Alternate Options:

              None

       -fshort-enums

              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.
              Default:

              OFF               No  source  code  annotations appear in
                                the assembly listing file,  if  one  is
                                produced.

              Description:

              This option produces an assembly listing file with source
              code annotations. The assembly  listing  file  shows  the
              source code as interspersed comments.

              To  use  this  option,  you  must also specify option -S,
              which causes an assembly listing to be generated.

              Alternate Options:

              None

       -fstack-protector[-keyword]

       -fno-stack-protector[-keyword]

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

              Arguments:

              keyword           Possible values are:

                                strong         When option -fstack-pro-
                                               tector-strong  is speci-
                                               fied, it  enables  stack
                                               overflow security checks
                                               for  routines  with  any
                                               type of buffer.

                                all            When option -fstack-pro-
                                               tector-all is specified,
                                               it  enables  stack over-
                                               flow 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

              cause a stack overflow and security violations.

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

              For an Intel-specific version of this feature, see option
              -fstack-security-check.

              Alternate Options:

              None

       -fstack-security-check

       -fno-stack-security-check

              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.

              Alternate Options:

              None

       -fsyntax-only

              Tells the compiler to check only for correct syntax.

              Arguments:
              Linux and OS X: None

       -ftemplate-depth=n

              Control  the  depth  in  which  recursive  templates  are
              expanded.

              Arguments:

              n                 The number of recursive templates  that
                                are expanded.

              Default:

              OFF               The  compiler  uses  default heuristics
                                for the depth of expansion.

              Description:

              Control  the  depth  in  which  recursive  templates  are
              expanded.  On  Linux*,  this  option is supported only by
              invoking the compiler with icpc.

              Alternate Options:

              None

       -ftls-model=model

              Changes the thread local storage (TLS) model.

              Arguments:

              model             Determines the TLS model  used  by  the
                                compiler. Possible values are:

                                global-dynamic Generates  a generic TLS
                                               code. The  code  can  be
                                               used  everywhere and the
                                               code  can  access  vari-
                                               ables  defined  anywhere
                                               else.    This    setting
                                               causes  the largest size
                                               code to be generated and
                                               uses  the  most run time
                                               to produce.

                                local-dynamic  Generates  an  optimized
                                               TLS  code.  To  use this
                                               setting,             the
                                               thread-local   variables
                                               must be defined  in  the
                                               use  this  setting,  the
                                               thread-local   variables
                                               must  be  defined in the
                                               executable.

              Default:

              OFF               The compiler  uses  default  heuristics
                                when determining the thread-local stor-
                                age model.

              Description:

              This option changes the thread local storage (TLS) model.
              Thread-local  storage  is  a mechanism by which variables
              are allocated in a way that causes one  instance  of  the
              variable per extant thread.

              For  more  information on the thread-storage localization
              models, see the appropriate gcc* documentation.

              For more information on the  thread-storage  localization
              models, see the appropriate clang* documentation.

              Alternate Options:

              None

       -ftrapuv

              Initializes stack local variables to an
                     unusual value to aid error detection.

              Arguments:

              None

              Default:

              OFF               The  compiler does not initialize local
                                variables.

              Description:

              This option  initializes  stack  local  variables  to  an
              unusual  value  to  aid  error detection. Normally, these
              local variables should be initialized in the application.
              It also unmasks the floating-point invalid exception.

              The  option  sets  any uninitialized local variables that
              are allocated on the stack to a value that  is  typically
              interpreted  as  a  very  large  integer  or  an  invalid
              resulting from speculated floating-point operations  from
              being trapped.

              For  more  details on using options -ftrapuv and /Qtrapuv
              with compiler option  O,  see  the  article  in  Intel(R)
              Developer  Zone titled Don't optimize when using -ftrapuv
              for uninitialized variable detection.

              Another way to detect uninitialized  local  scalar  vari-
              ables is by specifying keyword uninit for option check.

              Alternate Options:

              None

       -ftz

       -no-ftz

              Flushes denormal results to zero.

              Arguments:

              None

              Default:

              -ftz              Denormal results are flushed to zero.

                                Every   optimization  option  O  level,
                                except O0, sets [Q]ftz.

              Description:

              This option flushes denormal results  to  zero  when  the
              application  is  in  the  gradual  underflow mode. It may
              improve performance if the denormal values are not criti-
              cal to your application's behavior.

              The [Q]ftz option has no effect during compile-time opti-
              mization.

              The [Q]ftz option sets or resets  the  FTZ  and  the  DAZ
              hardware  flags.  If  FTZ  is  ON,  denormal results from
              floating-point calculations will  be  set  to  the  value
              zero.  If  FTZ  is OFF, denormal results remain as is. If
              DAZ is ON,  denormal  values  used  as  input  to  float-
              ing-point instructions will be treated as zero. If DAZ is
              OFF, denormal instruction inputs remain as  is.   Systems
              using Intel(R) 64 architecture have both FTZ and DAZ. FTZ
              and DAZ are not supported on all IA-32 architectures.


              If this option produces undesirable results of the numer-
              ical behavior of your program, you can turn  the  FTZ/DAZ
              mode  off  by using -no-ftz or /Qftz- in the command line
              while still benefiting from the O3 optimizations.

              NOTE: Option [Q]ftz is a performance option. Setting this
              option does not guarantee that all denormals in a program
              are flushed to zero. The  option  only  causes  denormals
              generated at run time to be flushed to zero.

              Alternate Options:

              None

       -funroll-all-loops

              Unroll  all  loops  even  if  the number of iterations is
              uncertain when the loop is entered.

              Arguments:

              None

              Default:

              OFF               Do not unroll all loops.

              Description:

              Unroll  all  loops,  even  if the number of iterations is
              uncertain when the loop is entered. There may  a  perfor-
              mance impact with this option.

              Alternate Options:

              None

       -funsigned-bitfields

       -fno-unsigned-bitfields

              Determines  whether  the default bitfield type is changed
              to unsigned.

              Arguments:

              None

              Default:

              -fno-unsigned-bitfields

              Arguments:

              None

              Default:

              OFF               Do not  change  default  char  type  to
                                unsigned.

              Description:

              Change default char type to unsigned.

              Alternate Options:

              None

       -fverbose-asm

       -fno-verbose-asm

              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 com-
              piler comments, including options  and  version  informa-
              tion.

              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.

              Alternate Options:

              None

       -fvisibility=keyword

                                extern         Sets    visibility    to
                                               extern.

                                hidden         Sets  visibility to hid-
                                               den.

                                internal       Sets    visibility    to
                                               internal.

                                protected      Sets  visibility to pro-
                                               tected.  This  value  is
                                               not  available  on OS X*
                                               systems.

              filename          Is the pathname of  a  file  containing
                                the  list  of  symbols whose visibility
                                you want to set. The  symbols  must  be
                                separated  by whitespace (spaces, tabs,
                                or newlines).

              Default:

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

              Description:

              This  option  specifies the default visibility for global
              symbols (syntax -fvisibility=keyword) or  the  visibility
              for  symbols in a file (syntax -fvisibility-keyword=file-
              name).

              Visibility  specified  by   -fvisibility-keyword=filename
              overrides  visibility  specified  by -fvisibility=keyword
              for symbols specified in a file.

              Option             Description

              -fvisibility=default -fvisibility-default=filename
                                Sets visibility of symbols to  default.
                                This  means other components can refer-
                                ence the symbol, and the symbol defini-
                                tion can be overridden (preempted) by a
                                definition of the same name in  another
                                component.

              -fvisibility=extern -fvisibility-extern=filename
                                Sets  visibility  of symbols to extern.
                                This means the  symbol  is  treated  as
                                though  it is defined in another compo-
                                referenced outside its defining  compo-
                                nent,  either  directly  or indirectly.
                                The affected  functions  can  never  be
                                called  from  another module, including
                                through function pointers.

              -fvisibility=protected -fvisibility-protected=filename
                                Sets  visibility  of  symbols  to  pro-
                                tected. This means 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 available on OS X* systems.

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

              If a symbol appears in more than one visibility filename,
              the setting with the least visibility takes precedence.

              The following shows the precedence of the visibility set-
              tings (from greatest to least visibility):

              · extern

              · default

              · protected

              · hidden

              · internal

              Note that extern visibility only applies to functions. If
              a variable symbol is specified as extern, it  is  assumed
              to be default.

              Alternate Options:

              None

       -fvisibility-inlines-hidden

              Causes  inline  member  functions  (those  defined in the
              class declaration) to be marked hidden.

              Architecture Restrictions: Only available on IA-32 archi-
              tecture

              Arguments:


              None

       -fzero-initialized-in-bss

       -fno-zero-initialized-in-bss

              Determines whether the compiler places
                     in the DATA section any variables explicitly  ini-
                     tialized 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* and OS X*)
              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

              Tells the compiler to generate full
                     debugging information in the object file.

              Arguments:

              None

              Default:

              OFF               No debugging information is produced.

              Description:
              Specifying   the   -g   or   -O0    option    sets    the
              -fno-omit-frame-pointer  option.  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).

              NOTE: When option -g is specified, debugging  information
              is  generated  in  the DWARF Version 3 format. Older ver-
              sions 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

       -g0

              Disables generation of symbolic debug information.

              Arguments:

              None

              Default:

              OFF               The compiler generates  symbolic  debug
                                information.

              Description:

              This  option disables generation of symbolic debug infor-
              mation.

              Alternate Options:

              None

       -gcc

       -no-gcc

       -gcc-sys

              Determines whether certain  GNU  macros  are  defined  or
              undefined.

              Arguments:

              None

              -gcc              Defines GNU macros.

              -no-gcc           Undefines GNU macros.

              -gcc-sys          Defines GNU macros only during compila-
                                tion of system headers.

              Alternate Options:

              None

       -gcc-include-dir (L*X only)

       -no-gcc-include-dir (L*X only)

              Controls  whether  the  gcc-specific include directory is
              put into the system include path.

              Arguments:

              None

              Default:

              -gcc-include-dir  The  gcc-specific  include directory is
                                put into the system include path.

              Description:

              This option controls  whether  the  gcc-specific  include
              directory is put into the system include path.

              If  you  specify  -no-gcc-include-dir,  the  gcc-specific
              include directory will not be put into the system include
              path.

              Alternate Options:

              None

       -gcc-name=name (L*X only)

              Lets you specify the name of the gcc compiler that should
              be used to set up the environment for C compilations.

              Arguments:

              name              Is the name of the gcc compiler to use.
                                It can include the path where  the  gcc
                                compiler is located.

              This  option  is  helpful  when  you  are  referencing  a
              non-standard gcc installation, or you have  multiple  gcc
              installations on your system. The compiler will match gcc
              version values to the gcc compiler you specify.

              The C++ equivalent to option -gcc-name is -gxx-name.

              Alternate Options:

              None

       -gdwarf-n

              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 informa-
                                               tion  using  the   DWARF
                                               Version 2 format.

                                3              Generates debug informa-
                                               tion  using  the   DWARF
                                               Version 3 format.

                                4              Generates debug informa-
                                               tion  using  the   DWARF
                                               Version  4  format. This
                                               setting is  only  avail-
                                               able on Linux*.

              Default:

              OFF               No debug information is generated. How-
                                ever, if compiler option -g  is  speci-
                                fied,  debugging  information is gener-
                                ated in the DWARF Version 3 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:

              Default:

              -global-hoist     Certain  optimizations are enabled that
                                can move memory loads.

              Description:

              This option enables certain optimizations that  can  move
              memory  loads to a point earlier in the program execution
              than where they appear in  the  source.  In  most  cases,
              these optimizations are safe and can improve performance.

              The negative form of the option is useful for some appli-
              cations,  such  as  those  that use shared or dynamically
              mapped memory, which can fail if  a  load  is  moved  too
              early  in  the  execution stream (for example, before the
              memory is mapped).

              Alternate Options:

              None

       -gnu-prefix=prefix (L*X only)

              Lets you specify a prefix that will be
                     added to the names of gnu  utilities  called  from
                     the compiler.

              Arguments:

              prefix            Is  a  string that prepends the name of
                                gnu tools called from the compiler. The
                                value depends on the gnu toolchain used
                                for a particular operating system.  For
                                example, for Wind River* Linux 6.x, the
                                prefix value will be x86_64-wrs-linux-.
                                You must append a hyphen to prefix only
                                if the toolchain  prefix  ends  with  a
                                hyphen.

                                You can specify a short name or a path-
                                name:

                                · short  name:  -gnu-prefix=prefix   In
                                  this  case,  the  compiler calls pre-
                                  fix<gnu_utility>      instead      of
                                  <gnu_utility>.  The utility with this
                                  name should be in the  PATH  environ-
                                  ment variable.

                                · pathname:         -gnu-prefix=/direc-

              This  option lets you specify a prefix that will be added
              to the names of gnu utilities called from  the  compiler.
              This  option  is  available for Linux*-targeted compilers
              but the host may be either Windows* or Linux*.

              If you specify option -gnu-prefix with  option  -gcc-name
              (or -gxx-name), the following occurs:

              · If  a  name  specified in -gcc-name (or -gxx-name) con-
                tains a full path to a binary then  option  -gnu-prefix
                has  no  effect  on  the specified name; other binutils
                will have the prefix.

              · Otherwise, option -gnu-prefix is applied  to  the  name
                specified in -gcc-name (or -gxx-name).

              The  above  approach  provides  flexibility to specify an
              alternative gcc name outside of the default toolchain. At
              the  same  time,  if  a  short name is provided in option
              -gcc-name, it is assumed to be  a  part  of  the  default
              toolchain and a prefix will be added.

              Instead  of using option -gnu-prefix, you can create sym-
              links for  the  short  names  of  gnu  utilities  in  the
              toolchain  and  add  them to the PATH. For example, ld-->
              i686-wrs-linux-gnu-ld.

              NOTE: Even though this option is not supported for a Win-
              dows-to-Windows  native  compiler,  it is supported for a
              Windows-host to Linux-target compiler.

              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.

       -gsplit-dwarf (L*X only)

              Creates a separate object file containing
                     DWARF debug information.

              Architectures:  Not available on Intel(R) 64 architecture
              targeting the
                     Intel(R)  Xeon  Phi(TM)  coprocessor  x100 product
                     family (formerly code  name  Knights  Corner),  on
                     IA-32  architecture  targeting  Intel(R)  Graphics
                     Technology, or on Intel(R) 64 architecture target-
                     ing Intel(R) Graphics Technology

              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 binu-
              tils-2.24 or later.  To debug the  resulting  executable,
              you must use gdb-7.6.1 or later.

              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.

              Alternate Options:

              None

       -guide[=n]

              Lets you set a level of guidance for
                     auto-vectorization,  auto  parallelism,  and  data
                     transformation.

              Arguments:
                                lelism,  vectorization, and data trans-
                                formation.

              Description:

              This option lets you set a level of guidance (advice) for
              auto-vectorization,  auto parallelism, and data transfor-
              mation. It causes the compiler to generate messages  sug-
              gesting ways to improve these optimizations.

              When this option is specified, the compiler does not pro-
              duce any objects or executables.

              You must also specify the [Q]parallel option  to  receive
              auto parallelism guidance.

              You  can  set levels of guidance for the individual guide
              optimizations by specifying one of the following options:

              [Q]guide-data-trans
                                Provides  guidance for data transforma-
                                tion.

              [Q]guide-par      Provides guidance for auto parallelism.

              [Q]guide-vec      Provides  guidance  for auto-vectoriza-
                                tion.

              If you specify the [Q]guide option and also  specify  one
              of  the  options setting a level of guidance for an indi-
              vidual guide optimization, the value set for the individ-
              ual  guide  optimization will override the setting speci-
              fied in [Q]guide.

              If you do not specify [Q]guide, but specify  one  of  the
              options  setting  a  level  of guidance for an individual
              guide optimization, option [Q]guide is enabled  with  the
              greatest  value  passed among any of the three individual
              guide optimizations specified.

              In debug mode, this option has no effect unless option O2
              (or  higher)  is explicitly specified in the same command
              line.

              NOTE: The compiler speculatively  performs  optimizations
              as  part  of  guide  analysis.  As a result, when you use
              guided auto-parallelism options with options that produce
              vectorization   or  auto-parallelizer  reports  (such  as
              option [q or Q]opt-report), the compiler generates  "LOOP
              WAS VECTORIZED" or similar messages as if the compilation
              was performed with the recommended changes.


              Arguments:

              n                 Is  an  optional  value  specifying the
                                level of guidance to be provided.

                                The values available are 1  through  4.
                                Value  1  indicates a standard level of
                                guidance. Value 4  indicates  the  most
                                advanced  level  of  guidance.  If n is
                                omitted, the default is 4.

              Default:

              OFF               You do not receive guidance  about  how
                                to   improve   optimizations  for  data
                                transformation.

              Description:

              This option lets you set a level  of  guidance  for  data
              transformation.  It  causes the compiler to generate mes-
              sages suggesting ways to improve that optimization.

              Alternate Options:

              None

       -guide-file[=filename]

              Causes the results of guided auto
                     parallelism to be output to a file.

              Arguments:

              filename          Is the name of the file for output.  It
                                can include a path.

              Default:

              OFF               Messages  that  are generated by guided
                                auto parallelism are output to  stderr.

              Description:

              This option causes the results of guided auto parallelism
              to be output to a file.

              This option is ignored unless you  also  specify  one  or
              more of the following options:

              · [Q]guide
              ple, if file.txt is specified, the  name  of  the  output
              file is file.txt. If you do not provide a file extension,
              the name of the file is filename.guide.

              If you do not specify filename, the name of the  file  is
              name-of-the-first-source-file.guide.  This  is  also  the
              name of the file if the name specified for filename  con-
              flicts  with  a  source file name provided in the command
              line.

              NOTE: If you specify the  [Q]guide-file  option  and  you
              also specify option [Q]guide-file-append, the last option
              specified on the command line takes precedence.

              Alternate Options:

              None

       -guide-file-append[=filename]

              Causes the results  of  guided  auto  parallelism  to  be
              appended to a file.

              Arguments:

              filename          Is the name of the file to be  appended
                                to. It can include a path.

              Default:

              OFF               Messages  that  are generated by guided
                                auto parallelism are output to  stderr.

              Description:

              This option causes the results of guided auto parallelism
              to be appended to a file.

              This option is ignored unless you  also  specify  one  or
              more of the following options:

              · [Q]guide

              · [Q]guide-vec

              · [Q]guide-data-trans

              · [Q]guide-par

              If  you  do  not  specify  a path, the compiler looks for
              filename in the current working directory.

              Alternate Options:

              None

       -guide-opts=string

              Tells the compiler to analyze certain
                     code and generate recommendations that may improve
                     optimizations.

              Arguments:

              string            Is  the  text denoting the code to ana-
                                lyze. The  string  must  appear  within
                                quotes.  It can take one or more of the
                                following forms: filenamefilename, rou-
                                tinefilename, range [, range]...  file-
                                name, routine, range [, range]...

                                If you specify more  than  one  of  the
                                above  forms  in  a string, a semicolon
                                must appear between each form.  If  you
                                specify   more  than  one  range  in  a
                                string, a  comma  must  appear  between
                                each  range. Optional blanks can follow
                                each parameter in the forms  above  and
                                they  can  also  follow  each form in a
                                string.

                                filename       Specifies the name of  a
                                               file  to be analyzed. It
                                               can include a path.

                                               If you do not specify  a
                                               path, the compiler looks
                                               for filename in the cur-
                                               rent  working directory.

                                routine        Specifies the name of  a
                                               routine  to be analyzed.
                                               You can include an iden-
                                               tifying parameter.

                                               The  name, including any
                                               parameter,    must    be
                                               enclosed    in    single
                                               quotes.

                                               The  compiler  tries  to
                                               uniquely   identify  the
                                               routine that corresponds
                                               to the specified routine
                                                 number   of   routines
                                                 selected as matches.

                                range          Specifies   a  range  of
                                               line numbers to  analyze
                                               in  the  file or routine
                                               specified.   The   range
                                               must   be  specified  in
                                               integers in the form:

                                               first_line_num-
                                               ber-last_line_number

                                               The  hyphen  between the
                                               line     numbers      is
                                               required.

              Default:

              OFF               You  do  not receive guidance on how to
                                improve optimizations. However, if  you
                                specify  the  [Q]guide option, the com-
                                piler analyzes and generates  recommen-
                                dations for all the code in an applica-
                                tion

              Description:

              This option tells the compiler to  analyze  certain  code
              and  generate  recommendations that may improve optimiza-
              tions.

              This option is ignored unless you  also  specify  one  or
              more of the following options:

              · [Q]guide

              · [Q]guide-vec

              · [Q]guide-data-trans

              · [Q]guide-par

              When  the [Q]guide-opts option is specified, a message is
              output that includes which parts of the input  files  are
              being  analyzed. If a routine is selected to be analyzed,
              the complete routine name will appear  in  the  generated
              message.

              When inlining is involved, you should specify callee line
              numbers.  Generated messages also use  callee  line  num-
              bers.
                                The values available are 1  through  4.
                                Value  1  indicates a standard level of
                                guidance. Value 4  indicates  the  most
                                advanced  level  of  guidance.  If n is
                                omitted, the default is 4.

              Default:

              OFF               You do not receive guidance  about  how
                                to  improve  optimizations  for  paral-
                                lelism.

              Description:

              This option lets you set a level  of  guidance  for  auto
              parallelism.  It causes the compiler to generate messages
              suggesting ways to improve that optimization.

              You must also specify the [Q]parallel option  to  receive
              auto parallelism guidance.

              Alternate Options:

              None

       -guide-profile=filename|dir [, [filename|dir]...]

              Specifies  a  loop profiler data file (or a set of files)
              when used with option -guide or /Qguide.

              Arguments:

              filename          Is  an  .xml  file  created from a loop
                                profiler run.

              dir               Is a directory  that  contains  one  or
                                more  .xml  files  from a loop profiler
                                run.

              Default:

              OFF               When the [Q]guide option is  specified,
                                the  guide  region is the whole file or
                                the   region   specified   by    option
                                [Q]guide-opts.

              Description:

              This option specifies a loop profiler data file (or a set
              of files) when used with the [Q]guide option.

              This option has no effect unless the [Q]guide option  has

              When the data is  from  [Q]profile-functions,  the  guide
              region will be the entire function containing the hottest
              functions.

              If you specify options  [Q]guide-opts  and  [Q]guide-pro-
              file, the compiler issues an error message.

              Alternate Options:

              None

       -guide-vec[=n]

              Lets  you set a level of guidance for auto-vectorization.

              Arguments:

              n                 Is  an  optional  value  specifying the
                                level of guidance to be provided.

                                The values available are 1  through  4.
                                Value  1  indicates a standard level of
                                guidance. Value 4  indicates  the  most
                                advanced  level  of  guidance.  If n is
                                omitted, the default is 4.

              Default:

              OFF               You do not receive guidance  about  how
                                to improve optimizations for vectoriza-
                                tion.

              Description:

              This  option  lets  you  set  a  level  of  guidance  for
              auto-vectorization.  It  causes  the compiler to generate
              messages suggesting ways to improve that optimization.

              Alternate Options:

              None

       -gxx-name=name (L*X only)

              Lets you specify the name of the g++ compiler that should
              be used to set up the environment for C++ compilations.

              Arguments:

              name              Is the name of the g++ compiler to use.
                                It  can  include the path where the g++

              provide.

              This option is helpful if you have multiple gcc++ instal-
              lations  on  your  system.  The compiler will match gcc++
              version values to the gcc++ compiler you specify.

              The C equivalent to option -gxx-name is -gcc-name.

              NOTE: When compiling a C++ file with icc, g++ is used  to
              get the environment.

              Alternate Options:

              None

       -H

              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[category]

              Displays all available compiler options or a category  of
              compiler options.

              Arguments:

              category          Is a category or class  of  options  to
                                display. Possible values are:

                                advanced       Displays  advanced opti-
                                               mization  options   that
                                               allow   fine  tuning  of
                                               compilation   or   allow
                                               control   over  advanced
                                               to   interpretation   of
                                               data  in programs or the
                                               storage of data.

                                deprecated     Displays  options   that
                                               have been deprecated.

                                diagnostics    Displays   options  that
                                               affect  diagnostic  mes-
                                               sages  displayed  by the
                                               compiler.

                                float          Displays  options   that
                                               affect    floating-point
                                               operations.

                                help           Displays all the  avail-
                                               able help categories.

                                inline         Displays   options  that
                                               affect inlining.

                                ipo            Displays Interprocedural
                                               Optimization       (IPO)
                                               options

                                language       Displays options affect-
                                               ing  the behavior of the
                                               compiler  language  fea-
                                               tures.

                                link           Displays    linking   or
                                               linker options.

                                misc           Displays   miscellaneous
                                               options  that do not fit
                                               within other categories.

                                openmp         Displays OpenMP and par-
                                               allel         processing
                                               options.

                                opt            Displays   options  that
                                               help you optimize  code.

                                output         Displays   options  that
                                               provide   control   over
                                               compiler output.

                                pgo            Displays  Profile Guided
                                               Optimization       (PGO)
                                               options.

              This  option displays all available compiler options or a
              category  of  compiler  options.  If  category   is   not
              specified,  all available compiler options are displayed.
              On Linux* systems, this option can also be  specified  as
              --help.

              Alternate Options:

              Linux and OS X: None

       -help-pragma

              Displays all supported pragmas.

              Arguments:

              None

              Default:

              OFF               No  list  is displayed unless this com-
                                piler option is specified.

              Description:

              This option displays  all  supported  pragmas  and  shows
              their syntaxes.

              Alternate Options:

              None

       -Idir

              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

              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

       -icc

       -no-icc

              Determines whether  certain  Intel  compiler  macros  are
              defined or undefined.

              Arguments:

              None

              Default:

              -icc or /Qicl     The __INTEL_COMPILER macros are set  to
                                represent  the  current  version of the
                                compiler.

              Description:

              This option determines  whether  certain  Intel  compiler
              macros are defined or undefined.

              dir               Is the name of the directory to add.

              Default:

              OFF               Include  file search paths include cer-
                                tain default directories.

              Description:

              This option adds a directory to the second  include  file
              search path (after -I).

              Alternate Options:

              None

       -imacros filename

              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

       -inline-calloc

       -no-inline-calloc

              Tells the compiler to inline calls to calloc()  as  calls
              to malloc() and memset().

              Architectures: All

              Arguments:

              None

              highly optimized for Intel(R)  microprocessors  than  for
              non-Intel microprocessors


              Optimization Notice


              = = = = = = = = = =

              Intel's  compilers  may  or  may not optimize to the same
              degree for non-Intel  microprocessors  for  optimizations
              that are not unique to Intel microprocessors. These opti-
              mizations include SSE2, SSE3, and SSSE3 instruction  sets
              and  other  optimizations.  Intel  does not guarantee the
              availability,  functionality,  or  effectiveness  of  any
              optimization   on  microprocessors  not  manufactured  by
              Intel.  Microprocessor-dependent  optimizations  in  this
              product  are intended for use with Intel microprocessors.
              Certain optimizations not specific to  Intel  microarchi-
              tecture  are  reserved  for Intel microprocessors. Please
              refer to the applicable product User and Reference Guides
              for  more  information regarding the specific instruction
              sets covered by this notice.

              Notice revision #20110804

              = = = = = = = = = =

              Alternate Options:

              None

       -inline-factor=n

       -no-inline-factor

              Specifies the percentage multiplier that
                     should  be  applied  to  all inlining options that
                     define upper limits.

              Arguments:

              n                 Is a positive  integer  specifying  the
                                percentage  value. The default value is
                                100 (a factor of 1).

              Default:

              -inline-factor=100
                                The compiler uses a  percentage  multi-
                                plier of 100.

              The  [Q]inline-factor  option takes the default value for
              each of the above options and multiplies it by n  divided
              by  100.  For  example, if 200 is specified, all inlining
              options that define upper limits are multiplied by a fac-
              tor  of  2.  This  option is useful if you do not want to
              individually increase each option limit.

              If you specify -no-inline-factor (Linux* and  OS  X*)  or
              /Qinline-factor- (Windows*), the following occurs:

              · Every  function  is  considered to be a small or medium
                function; there are no large functions.

              · There is no limit to the size a routine may  grow  when
                inline expansion is performed.

              · There  is  no limit to the number of times some routine
                may be inlined into a particular routine.

              · There is no limit to the number of times  inlining  can
                be applied to a compilation unit.

              To  see  compiler  values  for important inlining limits,
              specify option [q or Q]opt-report.

              CAUTION: When you use this  option  to  increase  default
              limits,  the  compiler may do so much additional inlining
              that it runs out of memory and terminates with an "out of
              memory" message.

              Alternate Options:

              None

       -inline-forceinline

              Instructs  the  compiler  to  force inlining of functions
              suggested for inlining whenever the compiler  is  capable
              doing so.

              Default:

              OFF               The  compiler  uses  default heuristics
                                for inline routine expansion.

              Description:

              This option instructs the compiler to force  inlining  of
              functions suggested for inlining whenever the compiler is
              capable doing so.

              Without  this  option,  the  compiler  treats   functions
              of  inline  to "forceinline", the compiler may do so much
              additional inlining that it runs out of memory and termi-
              nates with an "out of memory" message.

              Alternate Options:

              None

       -inline-level=n

              Specifies the level of inline function
                     expansion.

              Arguments:

              n                 Is the inline function expansion level.
                                Possible values are 0, 1, and 2.

              Default:

              -inline-level=2   This is the default  if  option  O2  is
                                specified  or  is in effect by default.
                                On Windows* systems, this is  also  the
                                default if option O3 is specified.

              -inline-level=0   This  is  the  default  if  option  -O0
                                (Linux* and OS X*) is specified.

              Description:

              This option specifies the level of inline function expan-
              sion.   Inlining   procedures  can  greatly  improve  the
              run-time performance of certain programs.

              Option             Description

              -inline-level=0 or
                                /Ob0 Disables inlining of  user-defined
                                functions.   Note  that statement func-
                                tions are always inlined.

              -inline-level=1   or /Ob1 Enables inlining when an inline
                                keyword or an inline attribute is spec-
                                ified. Also enables inlining  according
                                to the C++ language.

              -inline-level=2   or  /Ob2  Enables inlining of any func-
                                tion at the compiler's discretion.

              Alternate Options:

              None

              Default:

              -no-inline-max-per-compile
                                The  compiler  uses  default heuristics
                                for inline routine expansion.

              Description:

              This option the maximum number of times inlining  may  be
              applied to an entire compilation unit. It limits the num-
              ber of times that inlining can be applied.

              For  compilations  using  Interprocedural   Optimizations
              (IPO),  the entire compilation is a compilation unit. For
              other compilations, a compilation unit is a file.

              If you specify -no-inline-max-per-compile (Linux* and  OS
              X*)  or /Qinline-max-per-compile- (Windows*), there is no
              limit to the number of times inlining may be applied to a
              compilation unit.

              To  see  compiler  values  for important inlining limits,
              specify option [q or Q]opt-report.

              CAUTION: When you use this option to increase the default
              limit,  the  compiler  may do so much additional inlining
              that it runs out of memory and terminates with an "out of
              memory" message.

              Alternate Options:

              None

       -inline-max-per-routine=n

       -no-inline-max-per-routine

              Specifies the maximum number of times the
                     inliner may inline into a particular routine.

              Arguments:

              n                 Is  a  positive  integer that specifies
                                the maximum number of times the inliner
                                may inline into a particular routine.

              Default:

              -no-inline-max-per-routine
                                The  compiler  uses  default heuristics
                                for inline routine expansion.

              specify option [q or Q]opt-report.

              CAUTION: When you use this option to increase the default
              limit, the compiler may do so  much  additional  inlining
              that it runs out of memory and terminates with an "out of
              memory" message.

              Alternate Options:

              None

       -inline-max-size=n

       -no-inline-max-size

              Specifies the lower limit for the size of
                     what the inliner considers to be a large  routine.

              Arguments:

              n                 Is  a  positive  integer that specifies
                                the minimum size of  what  the  inliner
                                considers to be a large routine.

              Default:

              -inline-max-size  The  compiler sets the maximum size (n)
                                dynamically, based on the platform.

              Description:

              This option specifies the lower limit  for  the  size  of
              what the inliner considers to be a large routine (a func-
              tion). The inliner classifies routines as small,  medium,
              or large. This option specifies the boundary between what
              the inliner considers to be medium  and  large-size  rou-
              tines.

              The  inliner  prefers  to inline small routines. It has a
              preference against inlining large routines. So, any large
              routine is highly unlikely to be inlined.

              If  you specify -no-inline-max-size (Linux* and OS X*) or
              /Qinline-max-size- (Windows*), there are  no  large  rou-
              tines. Every routine is either a small or medium routine.

              To see compiler values  for  important  inlining  limits,
              specify option [q or Q]opt-report.

              CAUTION: When you use this option to increase the default
              limit, the compiler may do so  much  additional  inlining
              that it runs out of memory and terminates with an "out of

              n                 Is  a  positive  integer that specifies
                                the permitted increase in the routine's
                                size  when  inline  expansion  is  per-
                                formed.

              Default:

              -no-inline-max-total-size
                                The compiler  uses  default  heuristics
                                for inline routine expansion.

              Description:

              This  option specifies how much larger a routine can nor-
              mally grow when inline expansion is performed. It  limits
              the  potential  size of the routine. For example, if 2000
              is specified for n, the size of any routine will normally
              not increase by more than 2000.

              If  you  specify -no-inline-max-total-size (Linux* and OS
              X*) or /Qinline-max-total-size- (Windows*), there  is  no
              limit  to  the size a routine may grow when inline expan-
              sion is performed.

              To see compiler values  for  important  inlining  limits,
              specify option [q or Q]opt-report.

              CAUTION: When you use this option to increase the default
              limit, the compiler may do so  much  additional  inlining
              that it runs out of memory and terminates with an "out of
              memory" message.

              Alternate Options:

              None

       -inline-min-size=n

       -no-inline-min-size

              Specifies the upper limit for the size of
                     what the inliner considers to be a small  routine.

              Arguments:

              n                 Is  a  positive  integer that specifies
                                the maximum size of  what  the  inliner
                                considers to be a small routine.

              Default:

              So, when a routine is smaller than or equal to the speci-
              fied size, it is very likely to be inlined.

              If  you specify -no-inline-min-size (Linux* and OS X*) or
              /Qinline-min-size- (Windows*), there is no limit  to  the
              size of small routines. Every routine is a small routine;
              there are no medium or large routines.

              To see compiler values  for  important  inlining  limits,
              specify option [q or Q]opt-report.

              CAUTION: When you use this option to increase the default
              limit, the compiler may do so  much  additional  inlining
              that it runs out of memory and terminates with an "out of
              memory" message.

              Alternate Options:

              None

       -intel-extensions

       -no-intel-extensions

              Enables or disables all Intel(R) C and
                     Intel(R) C++ language extensions.

              Arguments:

              None

              Default:

              OFF               The Intel(R) C and  Intel(R)  C++  lan-
                                guage extensions are enabled.

              Description:

              This  option  enables  or  disables  all  Intel(R)  C and
              Intel(R) C++ language extensions.

              If you specify the  negative  form  of  the  option  (see
              above),  it disables all Intel(R) C and Intel(R) C++ lan-
              guage extensions. For example, it disables  the  Intel(R)
              Cilk(TM)  Plus  language  extensions, which include array
              notation, and it disables support for the decimal  float-
              ing-point types.

              Note that certain settings for the [Q]std compiler option
              can enable or disable decimal floating-point support:

              · The following [Q]std  settings  enable  decimal  float-
              Determines whether additional
                     interprocedural optimizations for single-file com-
                     pilation are enabled.

              Arguments:

              None

              Default:

              OFF               Some limited interprocedural  optimiza-
                                tions  occur, including inline function
                                expansion  for   calls   to   functions
                                defined within the current source file.
                                These optimizations  are  a  subset  of
                                full  intra-file  interprocedural opti-
                                mizations. Note that  this  setting  is
                                not  the  same as -no-ip (Linux* and OS
                                X*).

              Description:

              This option determines whether additional interprocedural
              optimizations for single-file compilation are enabled.

              The [Q]ip option enables additional interprocedural opti-
              mizations for single-file compilation.

              Options -no-ip (Linux and OS X) and /Qip-  (Windows)  may
              not   disable   inlining.  To  ensure  that  inlining  of
              user-defined    functions    is     disabled,     specify
              -inline-level=0or  -fno-inline (Linux and OS X), or spec-
              ify /Ob0 (Windows).  To ensure that  inliningof  compiler
              intrinsic  functions  is  disabled,  specify -fno-builtin
              (Linux and OS X) or /Oi- (Windows).

              Alternate Options:

              None

       -ip-no-inlining

              Disables full and partial inlining enabled by interproce-
              dural optimization options.

              Arguments:

              None

              Default:

              OFF               Inlining  enabled  by   interprocedural
              user-directed inlining specified by option /Ob1.

              Alternate Options:

              None

       -ip-no-pinlining

              Disables  partial  inlining  enabled  by  interprocedural
              optimization options.

              Arguments:

              None

              Default:

              OFF               Inlining  enabled  by   interprocedural
                                optimization options is performed.

              Description:

              This option disables partial inlining enabled by the fol-
              lowing interprocedural optimization options:

              · On Linux* and OS X* systems: -ip or -ipo

              · On Windows* systems: /Qip or /Qipo

              It has no effect on other interprocedural  optimizations.

              Alternate Options:

              None

       -ipo[n]

       -no-ipo

              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.

              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.

              Alternate Options:

              None

       -ipo-c

              Tells the compiler to optimize across multiple files  and
              generate a single object file.

              Arguments:

              None

              Default:

              OFF               The compiler does not generate a multi-
                                file object file.

              Description:

              This  option tells the compiler to optimize across multi-
              ple files  and  generate  a  single  object  file  (named
              ipo_out.o  on  Linux*  and  OS X* systems; ipo_out.obj on
              Windows* systems).

              It performs the same optimizations as the [Q]ipo  option,
              but  compilation stops before the final link stage, leav-
              ing an optimized object file that can be used in  further
              link steps.

              Alternate Options:

              None

       -ipo-jobsn

              Specifies  the  number  of commands (jobs) to be executed
              simultaneously during the link phase  of  Interprocedural
              Optimization (IPO).

              This option specifies the number of commands (jobs) to be
              executed simultaneously during the link phase  of  Inter-
              procedural  Optimization (IPO). It should only be used if
              the link-time compilation is  generating  more  than  one
              object. In this case, each object is generated by a sepa-
              rate compilation, which can be done in parallel.

              This option can be affected  by  the  following  compiler
              options:

              · [Q]ipo when applications are large enough that the com-
                piler decides to generate multiple object files.

              · [Q]ipon when n is greater than 1.

              · [Q]ipo-separate

              CAUTION:  Be  careful  when  using  this  option.  On   a
              multi-processor  system with lots of memory, it can speed
              application build time. However, if n is greater than the
              number of processors, or if there is not enough memory to
              avoid thrashing, this  option  can  increase  application
              build time.

              Alternate Options:

              None

       -ipo-S

              Tells  the compiler to optimize across multiple files and
              generate a single assembly file.

              Arguments:

              None

              Default:

              OFF               The compiler does not generate a multi-
                                file assembly file.

              Description:

              This option tells the compiler to optimize across  multi-
              ple  files  and  generate  a  single assembly file (named
              ipo_out.s on Linux* and OS  X*  systems;  ipo_out.asm  on
              Windows* systems).

              It  performs the same optimizations as the [Q]ipo option,
              but compilation stops before the final link stage,  leav-
              None

              Default:

              OFF               The compiler decides whether to  create
                                one or more object files.

              Description:

              This  option  tells  the  compiler to generate one object
              file for every  source  file.  It  overrides  any  [Q]ipo
              option  specification.

              Alternate Options:

              None

       -ipp[=lib]

              Tells the compiler to link to the some or
                     all  of the Intel(R) Integrated Performance Primi-
                     tives (Intel(R) IPP) libraries.

              Architecture Restrictions: Not available on  Intel(R)  64
              architecture targeting the
                     Intel(R) Xeon  Phi(TM)  coprocessor  x100  product
                     family  (formerly  code  name  Knights Corner), on
                     IA-32  architecture  targeting  Intel(R)  Graphics
                     Technology, or on Intel(R) 64 architecture target-
                     ing Intel(R) Graphics Technology

              Arguments:

              lib               Indicates the  Intel(R)  IPP  libraries
                                that  the compiler should link to. Pos-
                                sible 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   main
                                               libraries  set  and  the
                                               crypto library.

                                nonpic         (Linux* only) Tells  the
                                               compiler  to  link using
                                               the   version   of   the

              OFF               The  compiler  does  not  link  to  the
                                Intel(R) IPP libraries.

              Description:

              The  option tells the compiler to link to the some or all
              of  the  Intel(R)   Integrated   Performance   Primitives
              (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 run-time libraries.

              NOTE: On Windows* systems, this option  is  processed  by
              the  compiler,  which  adds  directives  to  the compiled
              object file that are processed by the linker.  On  Linux*
              and  OS  X*  systems,  this  option  is  processed by the
              icc/icpc command that initiates linking,  adding  library
              names explicitly to the link command.


              Optimization Notice


              = = = = = = = = = =

              Intel's  compilers  may  or  may not optimize to the same
              degree for non-Intel  microprocessors  for  optimizations
              that are not unique to Intel microprocessors. These opti-
              mizations include SSE2, SSE3, and SSSE3 instruction  sets
              and  other  optimizations.  Intel  does not guarantee the
              availability,  functionality,  or  effectiveness  of  any
              optimization   on  microprocessors  not  manufactured  by
              Intel.  Microprocessor-dependent  optimizations  in  this
              product  are intended for use with Intel microprocessors.
              Certain optimizations not specific to  Intel  microarchi-
              tecture  are  reserved  for Intel microprocessors. Please
              refer to the applicable product User and Reference Guides
              for  more  information regarding the specific instruction
              sets covered by this notice.

              Notice revision #20110804

              = = = = = = = = = =

              Alternate Options:

              None

       -ipp-link[=lib]


              lib               Specifies  the  Intel(R) IPP library to
                                use. Possible values are:

                                static         Tells  the  compiler  to
                                               link   to   the  set  of
                                               static          run-time
                                               libraries.

                                dynamic        Tells  the  compiler  to
                                               link  to  the   set   of
                                               dynamic         threaded
                                               run-time libraries.

              Default:

              dynamic           The compiler links to the Intel(R)  IPP
                                set of dynamic run-time libraries. How-
                                ever, if Linux* option -static is spec-
                                ified, the compiler links to the set of
                                static run-time libraries.

              Description:

              This option controls whether the compiler links to static
              or dynamic threaded Intel(R) Integrated Performance Prim-
              itives (Intel(R) IPP) run-time libraries.

              To use this option, you  must  also  specify  the  [Q]ipp
              option.


              Optimization Notice


              = = = = = = = = = =

              Intel's  compilers  may  or  may not optimize to the same
              degree for non-Intel  microprocessors  for  optimizations
              that are not unique to Intel microprocessors. These opti-
              mizations include SSE2, SSE3, and SSSE3 instruction  sets
              and  other  optimizations.  Intel  does not guarantee the
              availability,  functionality,  or  effectiveness  of  any
              optimization   on  microprocessors  not  manufactured  by
              Intel.  Microprocessor-dependent  optimizations  in  this
              product  are intended for use with Intel microprocessors.
              Certain optimizations not specific to  Intel  microarchi-
              tecture  are  reserved  for Intel microprocessors. Please
              refer to the applicable product User and Reference Guides
              for  more  information regarding the specific instruction
              sets covered by this notice.

              architecture, targeting the
                     Intel(R)  Xeon  Phi(TM)  coprocessor  x100 product
                     family (formerly code name Knights Corner)

              Arguments:

              prefix            Is the prefix to use.

              Default:

              OFF

              Description:

              Options for indicating the prefix for referencing  direc-
              tories  containing  header  files. Use prefix with option
              -iwithprefix as a prefix.

              Alternate Options:

              None

       -iquote dir

              Add 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

              Specifies a directory to add to the start
                     of the system include path.

              Architecture  Restrictions:  Not available on Intel(R) 64
              Description:

              This option specifies a directory to add  to  the  system
              include  path. The compiler searches the specified direc-
              tory 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  compati-
              bility with gcc.

              Alternate Options:

              None

       -iwithprefixdir

              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.

              Architecture Restrictions: Not available on  Intel(R)  64
              architecture targeting the
                     Intel(R) Xeon  Phi(TM)  coprocessor  x100  product
                     family (formerly code name Knights Corner)

              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

              Similar to -iwithprefix except the
                     include  directory  is placed in the same place as
                     -I command line include directories.

              Architecture Restrictions: Not available on  Intel(R)  64
              architecture targeting the
              placed in the same  place  as  -I  command  line  include
              directories.

              Alternate Options:

              None

       -lstring

              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 direc-
              tories 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.

              Alternate Options:

              None

       -Ldir

              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:

       -mcode

              Tells the compiler which features it may
                     target, including which instruction  sets  it  may
                     generate.

              Architecture  Restrictions:  Not available on Intel(R) 64
              architecture targeting the
                     Intel(R)  Xeon  Phi(TM)  coprocessor  x100 product
                     family (formerly code name Knights Corner)

              Arguments:

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

                                avx            May   generate  Intel(R)
                                               Advanced  Vector  Exten-
                                               sions   (Intel(R)  AVX),
                                               SSE4.2,  SSE4.1,   SSE3,
                                               SSE2,   SSE,  and  SSSE3
                                               instructions.

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

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

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

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

                                sse2           May   generate  Intel(R)
                                               SSE2  and  SSE  instruc-
                                               tions.   This  value  is
                                               only available on  Linux
                                               systems.
                                               settings. It  also  dis-
                                               ables  all  feature-spe-
                                               cific optimizations  and
                                               instructions. This value
                                               is  only  available   on
                                               Linux*   systems   using
                                               IA-32 architecture.

              Default:

              Linux* systems:   -msse2 OS X* systems using IA-32 archi-
                                tecture:  -msse3  OS  X*  systems using
                                Intel(R) 64 architecture:  -mssse3  For
                                more information on the default values,
                                see Arguments above.

              Description:

              This option tells the compiler which features it may tar-
              get, including which instruction sets it may generate.

              Code  generated  with these options should execute on any
              compatible, non-Intel processor with support for the cor-
              responding instruction set.

              Options  -x  and  -m  are mutually exclusive. If both are
              specified, the compiler uses the last one  specified  and
              generates a warning.

              Linux*  systems: For compatibility with gcc, the compiler
              allows the following options but they have no effect. You
              will get a warning error, but the instructions associated
              with the name will not be generated. You should  use  the
              suggested replacement options.

              gcc Compatibility Option (Linux*)
                                Suggested Replacement Option

              -mfma             -march=core-avx2

              -mbmi,            -mavx2, -mlzcnt -march=core-avx2

              -mmovbe           -march=atom -minstruction=movbe

              -mcrc32,          -maes, -mpclmul, -mpopcnt -march=corei7

              -mvzeroupper      -march=corei7-avx

              -mfsgsbase,       -mrdrnd, -mf16c -march=core-avx-i

              Many of the  above  gcc  options  are  not  available  on
              Intel(R)  64  architecture  targeting  the  Intel(R) Xeon
                     Intel(R)  Xeon  Phi(TM)  coprocessor  x100 product
                     family (formerly code  name  Knights  Corner),  on
                     IA-32  architecture  targeting  Intel(R)  Graphics
                     Technology, or on Intel(R) 64 architecture target-
                     ing Intel(R) Graphics Technology

              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

       -m32

       -m64

              Tells the compiler to generate code for a
                     specific architecture.

              Architecture  Restrictions:  Not available on Intel(R) 64
              architecture targeting the
                     Intel(R)  Xeon  Phi(TM)  coprocessor  x100 product
                     family (formerly code name Knights Corner)

              Arguments:

              None

              Default:

              OFF               The compiler's behavior depends on  the
                                host system.

              Description:

              These  options  tell  the compiler to generate code for a
              specific architecture.

              Option             Description
              Alternate Options:

              None

       -m80387

       -mno-80387

              Specifies whether the compiler can use
                     x87 instructions.

              Architectures:  Not available on IA-32 architecture  tar-
              geting Intel(R)
                     Graphics Technology, or on Intel(R)  64  architec-
                     ture targeting Intel(R) Graphics Technology

              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 com-
              piler from using x87 instructions.  If  the  compiler  is
              forced  to  generate x87 instructions, it issues an error
              message.

              Alternate Options:

              -m[no-]x87

       -malign-double

       -mno-align-double

              Determines whether double, long  double,  and  long  long
              types  are  naturally aligned.  This option is equivalent
              to specifying option align.

              Architecture Restrictions: Only available on IA-32 archi-
              tecture

              Arguments:

              None

       -map-opts (L*X only)

              Maps one or more compiler options to their equivalent  on
              a different operating system.

              Arguments:

              None

              Default:

              OFF               No platform mappings are performed.

              Description:

              This option maps one or more compiler  options  to  their
              equivalent on a different operating system. The result is
              output to stdout.

              On Windows systems, the options you provide are  presumed
              to  be Windows options, so the options that are output to
              stdout will be Linux equivalents.

              On Linux systems, the options you provide are presumed to
              be  Linux options, so the options that are output to std-
              out will be Windows equivalents.

              The tool can be invoked from the compiler command line or
              it can be used directly.

              No  compilation is performed when the option mapping tool
              is used.

              This option is useful if you have both compilers and want
              to convert scripts or makefiles.

              NOTE:  Compiler options are mapped to their equivalent on
              the architecture you are using. For example, if  you  are
              using  a processor with IA-32 architecture, you will only
              see equivalent options that are available  on  processors
              with IA-32 architecture.

              Alternate Options:

              None

       -march=processor

              Tells the compiler to generate code for
                     processors that support certain features.

                                broadwell haswell
                                               ivybridge   knl   sandy-
                                               bridge  silvermont  sky-
                                               lake  Optimizes code for
                                               processors that  support
                                               the  specified  Intel(R)
                                               microarchitecture   code
                                               name.

                                               Keywords knl and silver-
                                               mont are only  available
                                               on Linux* systems.

                                core-avx2      Generates  code for pro-
                                               cessors   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  pro-
                                               cessors   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  pro-
                                               cessors   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 pro-
                                               cessors   that   support
                                               Intel(R)  SSE4 Efficient
                                               Accelerated  String  and
                                               Text Processing instruc-
                                               tions. May also generate
                                               code  for  Intel(R) SSE4
                                               Vectorizing Compiler and
                                               Media       Accelerator,
                                               Intel(R)   SSE3,   SSE2,
                                               SSE,  and SSSE3 instruc-

                                core2          Generates  code  for the
                                               Intel(R) Core(TM) 2 pro-
                                               cessor family.

                                pentium-mmx    Generates  for  Intel(R)
                                               Pentium(R)   with    MMX
                                               technology.

                                pentiumpro     Generates  for  Intel(R)
                                               Pentium(R)  Pro,   Intel
                                               Pentium  II,  and  Intel
                                               Pentium III  processors.

                                pentium4m      Generates  for  Intel(R)
                                               Pentium(R) 4  processors
                                               with MMX technology.

                                pentium-m pentium4 pentium3 pentium
                                               Generates    code    for
                                               Intel(R) Pentium(R) pro-
                                               cessors.  Value pentium3
                                               is  only  available   on
                                               Linux* systems.

              Default:

              pentium4          If no architecture option is specified,
                                value pentium4 is used by the  compiler
                                to generate code.

              Description:

              This  option tells the compiler to generate code for pro-
              cessors that support certain features.

              If you specify both the -ax and -march options, the  com-
              piler will not generate Intel-specific instructions.

              Specifying -march=pentium4 sets -mtune=pentium4.

              For  compatibility, a number of historical processor val-
              ues are also supported, but the generated code  will  not
              differ from the default.


              Optimization Notice


              = = = = = = = = = =

              Intel's  compilers  may  or  may not optimize to the same
              Notice revision #20110804

              = = = = = = = = = =

              Alternate Options:

              -march=pentium3   Linux: -xSSE

                                OS X: None

              -march=pentium4 -march=pentium-m
                                Linux: -xSSE2

                                OS X: None

              -march=core2      Linux: -xSSSE3

                                OS X: 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.

              Alternate Options:

              None
                                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   address-
                                               ing.

                                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-rel-
                                               ative   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 architec-
                                ture, 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.

              Preprocess and compile, generating output
                     file containing dependency information ending with
                     extension .d.

              Architecture  Restrictions:  Not available on Intel(R) 64
              architecture targeting the
                     Intel(R)  Xeon  Phi(TM)  coprocessor  x100 product
                     family (formerly code  name  Knights  Corner),  on
                     IA-32  architecture  targeting  Intel(R)  Graphics
                     Technology, or on Intel(R) 64 architecture target-
                     ing Intel(R) Graphics Technology

              Arguments:

              None

              Default:

              OFF               The  compiler  does not generate depen-
                                dency information.

              Description:

              Preprocess and compile, generating output file containing
              dependency information ending with extension .d.

              Alternate Options:

              None

              Tells the linker to search for unresolved references in a
              multithreaded, dynamic-link run-time library.

              Arguments:

              None

              Default:

              OFF               The linker searches for unresolved ref-
                                erences in  a  single-threaded,  static
                                run-time library.

              Description:

              This  option  tells  the  linker to search for unresolved
              references  in  a   multithreaded,   dynamic-link   (DLL)
              run-time  library.   You  can  also specify /MDd, where d
              indicates a debug version.

              This option is processed  by  the  compiler,  which  adds
              architecture targeting Intel(R)
                     MIC Architecture

              Arguments:

              None

              Default:

              OFF               All  references  are generated as posi-
                                tion independent.

              Description:

              This option generates code that is not  position-indepen-
              dent but has position-independent external references.

              The  generated code is suitable for building executables,
              but it is not suitable for building shared libraries.

              This option may reduce code size and produce  more  effi-
              cient code. It overrides the -fpic compiler option.

              Alternate Options:

              None

       -MFfilename

              Tells the compiler to generate makefile
                     dependency information in a file.

              Architecture  Restrictions:  Not available on Intel(R) 64
              architecture targeting the
                     Intel(R)  Xeon  Phi(TM)  coprocessor  x100 product
                     family (formerly code  name  Knights  Corner),  on
                     IA-32  architecture  targeting  Intel(R)  Graphics
                     Technology, or on Intel(R) 64 architecture target-
                     ing Intel(R) Graphics Technology

              Arguments:

              filename          Is the name of the file where the make-
                                file dependency information  should  be
                                placed.

              Default:

              OFF               The compiler does not generate makefile
                                dependency information in files.

              Description:
              Architecture Restrictions: Not available on  Intel(R)  64
              architecture targeting the
                     Intel(R) Xeon  Phi(TM)  coprocessor  x100  product
                     family  (formerly  code  name  Knights Corner), on
                     IA-32  architecture  targeting  Intel(R)  Graphics
                     Technology, or on Intel(R) 64 architecture target-
                     ing Intel(R) Graphics Technology

              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

       -mgpu-arch=arch (L*X only)

              Builds the offload code for graphics to
                     run on  a  particular  version  of  the  processor
                     graphics,  as  specified  by  the option value. It
                     causes the linker to invoke a compiler that trans-
                     lates  the  virtual  Instruction  Set Architecture
                     (ISA) of the offload executable  into  the  native
                     ISA  for  the  version  of  the processor graphics
                     specified. This option only  applies  to  Intel(R)
                     Graphics Technology.

              Architecture   Restrictions:   Only  available  on  IA-32
              architecture targeting Intel(R)
                     Graphics  Technology, and on Intel(R) 64 architec-
                     ture targeting Intel(R) Graphics Technology

              Arguments:

              arch              Indicates to the  compiler  the  target
                                ISA for the compilation.  Possible val-
                                ues are:

                                skylake        May  generate   instruc-
                                               Intel(R)  microarchitec-
                                               ture  code  name  Broad-
                                               well.

                                haswell        May   generate  instruc-
                                               tions for  the  graphics
                                               processor   that  is  on
                                               Intel(R)  microarchitec-
                                               ture  code name Haswell.

              Default:

              OFF               The  compiler  generates  virtual   ISA
                                instructions.   At runtime, the virtual
                                instructions  must  be  compiled   into
                                native  ISA  code  for  the platform on
                                which the executable is to run.

              Description:

              This option builds the offload code for graphics to runon
              a particular version of the processor graphics, as speci-
              fied by the option value. It causes the linker to  invoke
              a  compiler  that  translates the virtual Instruction Set
              Architecture (ISA) of the  offload  executable  into  the
              native  ISA  for  the  version  of the processor graphics
              specified. For  information  about  applicable  operating
              systems  for  Intel(R) Graphics Technology, see Overview:
              Intel(R) Graphics Technology.

              When this option is not used, the executable is based  on
              the  virtual  ISA, which is portable across platforms. In
              this case, the virtual ISA  is  compiled  at  runtime  by
              invoking the "Just-In-Time" compiler.

              This  option  should  improve  performance of native code
              generation for graphics applications because the compila-
              tion  will  be  performed at link time instead of at run-
              time. It may also help  you  avoid  some  overhead  costs
              associated with compiling virtual ISA code at runtime.

              The  following  shows  the  current mapping table for the
              possible ISA target values:

              Alternate Options:

              None

       -mgpu-asm-dump[=filename] (L*X only)

              Tells the compiler to generate a native
                     assembly listing for the processor  graphics  code
                                assembly listing.

              Default:

              OFF               No native assembly listing is generated
                                for the processor graphics code  to  be
                                offloaded.

              Description:

              This  option  tells  the  compiler  to  generate a native
              assembly listing for the processor graphics  code  to  be
              offloaded.

              The  assembly  listing  can only be generated when native
              code is generated at link time. Both the assembly listing
              and the target executable are generated.

              To   use  this  option,  you  must  also  specify  option
              -mgpu-arch (Linux*) or /Qgpu-arch (Windows*).

              Alternate Options:

              None

       -minstruction=[no]movbe

              Determines whether MOVBE instructions are
                     generated for certain Intel processors.

              Architecture Restrictions: Not available on  Intel(R)  64
              architecture targeting the
                     Intel(R) Xeon  Phi(TM)  coprocessor  x100  product
                     family  (formerly  code  name  Knights Corner), on
                     IA-32  architecture  targeting  Intel(R)  Graphics
                     Technology, or on Intel(R) 64 architecture target-
                     ing Intel(R) Graphics Technology

              Arguments:

              None

              Default:

              –minstruction=nomovbe
                                The compiler does  not  generate  MOVBE
                                instructions for Intel(R) Atom(TM) pro-
                                cessors.

              Description:

              This option determines  whether  MOVBE  instructions  are
                SSE4.2) and MOVBE.

              If   -minstruction=nomovbe  or  /Qinstruction:nomovbe  is
              specified, the following occurs:

              · The compiler optimizes code for the  Intel(R)  Atom(TM)
                processor, but it does not generate MOVBE instructions.

              · Generated  executables  can  be  run  on   non-Intel(R)
                Atom(TM)  processors  that  support  Intel(R)  SSE3  or
                Intel(R) SSE4.2.

              Alternate Options:

              None

       -mkl[=lib]

              Tells the compiler to link to certain
                     libraries in  the  Intel(R)  Math  Kernel  Library
                     (Intel(R) MKL). On Windows systems, you must spec-
                     ify this option at compile time.

              Arguments:

              lib               Indicates which  Intel(R)  MKL  library
                                files should be linked. Possible values
                                are:

                                parallel       Tells  the  compiler  to
                                               link  using the threaded
                                               libraries     in     the
                                               Intel(R)  MKL.  This  is
                                               the   default   if   the
                                               option is specified with
                                               no lib.

                                sequential     Tells  the  compiler  to
                                               link  using  the sequen-
                                               tial  libraries  in  the
                                               Intel(R) MKL.

                                cluster        Tells  the  compiler  to
                                               link  using  the   clus-
                                               ter-specific   libraries
                                               and    the    sequential
                                               libraries     in     the
                                               Intel(R)   MKL.    Clus-
                                               ter-specific   libraries
                                               are not available for OS
                                               X*.


              -mkl -static-intel


              On Windows* systems, static linking is the  default  when
              you specify /Qmkl. To link with Intel(R) MKL dynamically,
              you must specify:

              /Qmkl /MD


              For more information about using MKL libraries,  see  the
              article  in Intel(R) Developer Zone titled: Intel(R) Math
              Kernel Library Link Line Advisor,  which  is  located  in
              https://software.intel.com/en-us/arti-
              cles/intel-mkl-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. On Linux* and  OS  X  sys-
              tems, the driver must add the library names explicitly to
              the link command.

              NOTE: If you specify option  [Q]mkl  or  [Q]mkl=parallel,
              and you also specify option [Q]tbb, the compiler links to
              the standard threaded version of the Intel(R)  MKL.  How-
              ever,  if  you specify [Q]mkl or [Q]mkl=parallel, and you
              also specify option [Q]tbb and option [q or Q]openmp, the
              compiler  links  to  the  OpenMP* threaded version of the
              Intel(R) MKL.


              Optimization Notice


              = = = = = = = = = =

              Intel's compilers may or may not  optimize  to  the  same
              degree  for  non-Intel  microprocessors for optimizations
              that are not unique to Intel microprocessors. These opti-
              mizations  include SSE2, SSE3, and SSSE3 instruction sets
              and other optimizations. Intel  does  not  guarantee  the
              availability,  functionality,  or  effectiveness  of  any
              optimization  on  microprocessors  not  manufactured   by
              Intel.  Microprocessor-dependent  optimizations  in  this
              product are intended for use with Intel  microprocessors.
              Certain  optimizations  not specific to Intel microarchi-
              tecture are reserved for  Intel  microprocessors.  Please
              refer to the applicable product User and Reference Guides
              for more information regarding the  specific  instruction
              sets covered by this notice.

              architecture targeting the
                     Intel(R) Xeon  Phi(TM)  coprocessor  x100  product
                     family  (formerly  code  name  Knights Corner), on
                     IA-32  architecture  targeting  Intel(R)  Graphics
                     Technology, or on Intel(R) 64 architecture target-
                     ing Intel(R) Graphics Technology

              Arguments:

              n                 Specifies the size of the  long  double
                                data type.  Possible values are:

                                64             Specifies  that the size
                                               of the long double  data
                                               type is 64 bits.

                                80             Specifies  that the size
                                               of the long double  data
                                               type is 80 bits. This is
                                               the default.

              Default:

              -mlong-double-80  Specifies that the  size  of  the  long
                                double data type is 80 bits.

              Description:

              This  option  lets you override the default configuration
              of the long double data type.

              When you specify -mlong-double-64, the size of  the  long
              double  data  type  is  8 bytes and the macro __LONG_DOU-
              BLE_64__ is defined.

              When you specify -mlong-double-80, the size of  the  long
              double data type is 12 bytes on IA-32 architecture and 16
              bytes on Intel(R) 64 architecture.

              This option has no effect on  floating-point  significand
              precision.  That  must be specified by using the -pc64 or
              -pc80 option.

              Note that this option has no effect when you  pass  argu-
              ments.  When  you  pass arguments, the 64-bit long double
              data type is treated as the double data type  and  it  is
              always 64-bit.

              Remember to include the math.h and complex.h header files
              when you use this option.

              The following restrictions apply to this option:

       -MM

              Tells the compiler to generate makefile
                     dependency lines for each source file.

              Architecture Restrictions: Not available on  Intel(R)  64
              architecture targeting the
                     Intel(R) Xeon  Phi(TM)  coprocessor  x100  product
                     family  (formerly  code  name  Knights Corner), on
                     IA-32  architecture  targeting  Intel(R)  Graphics
                     Technology, or on Intel(R) 64 architecture target-
                     ing Intel(R) Graphics Technology

              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

              Tells the compiler to generate an output
                     file containing dependency information.

              Architecture  Restrictions:  Not available on Intel(R) 64
              architecture targeting the
                     Intel(R)  Xeon  Phi(TM)  coprocessor  x100 product
                     family (formerly code  name  Knights  Corner),  on
                     IA-32  architecture  targeting  Intel(R)  Graphics
                     Technology, or on Intel(R) 64 architecture target-
                     ing Intel(R) Graphics Technology

              Arguments:

              None

              Default:


              None

       -mmic  (L*X only)

              Builds an application that runs natively
                     on Intel(R) 64 architecture targeting the Intel(R)
                     Xeon Phi(TM) coprocessor x100 product family (for-
                     merly code name Knights Corner).

              Architecture Restrictions: Only available on Intel(R)  64
              architecture targeting the
                     Intel(R) Xeon  Phi(TM)  coprocessor  x100  product
                     family (formerly code name Knights Corner)

              Arguments:

              None

              Default:

              OFF               The  compiler  builds  a  heterogeneous
                                application.   You  must  specify  this
                                option  to  build  an  application that
                                runs natively on Intel(R) 64  architec-
                                ture   targeting   the   Intel(R)  Xeon
                                Phi(TM) coprocessor x100 product family
                                (formerly code name Knights Corner).

              Description:

              This option enables the cross compiler to build an appli-
              cation that runs natively on Intel(R)  MIC  Architecture.
              It is only available on the command line.

              When  you use this option, the compiler defines the macro
              __MIC__.

              NOTE: When you specify Windows* option  /Qmic,  you  must
              specify  any  other  options  on  the command line in the
              Linux* form. This is because all other options are passed
              directly to the native compiler for Intel(R) 64 architec-
              ture targeting the Intel(R) Xeon Phi(TM) coprocessor x100
              product family (formerly code name Knights Corner), which
              is a Windows*-hosted Linux* compiler.

              Alternate Options:

              None

       -momit-leaf-frame-pointer

              Default:

              Varies            If       you       specify       option
                                -fomit-frame-pointer (or it is  set  by
                                default),      the      default      is
                                -momit-leaf-frame-pointer. If you spec-
                                ify option -fno-omit-frame-pointer, the
                                default                              is
                                -mno-omit-leaf-frame-pointer.


              Description:

              This option determines whether the frame pointer is omit-
              ted 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  com-
                                binations  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.
              Default:

              OFF               The  compiler  does not generate depen-
                                dency information unless it is told  to
                                do so.

              Description:

              This  option tells the compiler to add a phony target for
              each dependency.

              Note that this option is not related to  Windows*  option
              /MP.

              Alternate Options:

              None

       -mp1

              Improves floating-point precision and
                     consistency.

              Arguments:

              None

              Default:

              OFF               The compiler provides good accuracy and
                                run-time performance at the expense  of
                                less consistent floating-point results.

              Description:

              This  option  improves  floating-point  consistency.   It
              ensures  the  out-of-range check of operands of transcen-
              dental functions and  improves  the  accuracy  of  float-
              ing-point compares.

              This  option  prevents the compiler from performing opti-
              mizations that change NaN comparison semantics and causes
              all  values  to be truncated to declared precision before
              they are used in comparisons. It also causes the compiler
              to  use  library  routines  that  give  better  precision
              results compared to the X87 transcendental  instructions.

              This  option  disables  fewer  optimizations and has less
              impact  on  performance  than  option  -fp-model  precise
              (Linux* and OS X*) or option /fp:precise (Windows*).

              Alternate Options:
                     ing Intel(R) Graphics Technology

              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  depen-
              dency  generation.  It is similar to -MT, but quotes spe-
              cial Make characters.

              Alternate Options:

              None

       -mregparm=n

              Control the number registers used to pass  integer  argu-
              ments.

              Architecture Restrictions: Only available on IA-32 archi-
              tecture

              Arguments:

              n                 Specifies the number  of  registers  to
                                use when passing integer arguments. You
                                can specify at most 3 registers. If you
                                specify a nonzero value for n, you must
                                build all  modules,  including  startup
                                modules,  and  all libraries, including
                                system libraries, with the same  value.

              Default:

              OFF               The  compiler does not use registers to
                                pass arguments.

              Description:

              Control the number registers used to pass  integer  argu-
              ments.   This  option  is provided for compatibility with
              gcc.

              Alternate Options:

                                               use the most recent  ABI
                                               implementation.

                                1              Tells  the  compiler  to
                                               use the ABI  implementa-
                                               tion  that is compatible
                                               with gcc 3.4.6  and  icc
                                               15.0.

              Default:

              0                 The  compiler  uses the most recent ABI
                                implementation.

              Description:

              This option determines which version of  the  Application
              Binary  Interface (ABI) is used for the regparm parameter
              passing convention. This option allows compatibility with
              previous versions of gcc and icc.

              Alternate Options:

              None

       -MTtarget

              Changes the default target rule for
                     dependency generation.

              Architecture  Restrictions:  Not available on Intel(R) 64
              architecture targeting the
                     Intel(R)  Xeon  Phi(TM)  coprocessor  x100 product
                     family (formerly code  name  Knights  Corner),  on
                     IA-32  architecture  targeting  Intel(R)  Graphics
                     Technology, or on Intel(R) 64 architecture target-
                     ing Intel(R) Graphics Technology

              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  depen-
              dency generation.

              Arguments:

              processor         Is the processor for which the compiler
                                should  perform optimizations. Possible
                                values are:

                                generic        Optimizes code  for  the
                                               compiler's       default
                                               behavior.

                                broadwell haswell
                                               ivybridge   knl   sandy-
                                               bridge  silvermont  sky-
                                               lake Optimizes code  for
                                               processors  that support
                                               the  specified  Intel(R)
                                               microarchitecture   code
                                               name.

                                               Keywords knl and silver-
                                               mont  are only available
                                               on Windows*  and  Linux*
                                               systems.

                                core-avx2      Optimizes  code for pro-
                                               cessors   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  pro-
                                               cessors   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  pro-
                                               cessors   that   support
                                               Intel(R) Advanced Vector
                                               Extensions     (Intel(R)
                                               AVX),  Intel(R)  SSE4.2,
                                               SSE4.1, SSE3, SSE2, SSE,
                                               and SSSE3  instructions.

                                               cessors   that   support
                                               MOVBE      instructions,
                                               depending on the setting
                                               of option  -minstruction
                                               (Linux*  and  OS  X*) or
                                               /Qinstruction      (Win-
                                               dows*).  May also gener-
                                               ate   code   for   SSSE3
                                               instructions         and
                                               Intel(R) SSE3, SSE2, and
                                               SSE instructions.

                                core2          Optimizes     for    the
                                               Intel(R) Core(TM) 2 pro-
                                               cessor family, including
                                               support   for   MMX(TM),
                                               Intel(R) SSE, SSE2, SSE3
                                               and  SSSE3   instruction
                                               sets.

                                pentium-mmx    Optimizes  for  Intel(R)
                                               Pentium(R)   with    MMX
                                               technology.

                                pentiumpro     Optimizes  for  Intel(R)
                                               Pentium(R)  Pro,   Intel
                                               Pentium  II,  and  Intel
                                               Pentium III  processors.

                                pentium4m      Optimizes  for  Intel(R)
                                               Pentium(R) 4  processors
                                               with MMX technology.

                                pentium-m pentium4 pentium3 pentium
                                               Optimizes    code    for
                                               Intel(R) Pentium(R) pro-
                                               cessors.  Value pentium3
                                               is  only  available   on
                                               Linux* systems.

              Default:

              generic           Code  is  generated  for the compiler's
                                default behavior.

              Description:

              This option performs optimizations for  specific  proces-
              sors.

              The resulting executable is backwards compatible and gen-
              erated code is optimized  for  specific  processors.  For
              and  other  optimizations.  Intel  does not guarantee the
              availability,  functionality,  or  effectiveness  of  any
              optimization   on  microprocessors  not  manufactured  by
              Intel.  Microprocessor-dependent  optimizations  in  this
              product  are intended for use with Intel microprocessors.
              Certain optimizations not specific to  Intel  microarchi-
              tecture  are  reserved  for Intel microprocessors. Please
              refer to the applicable product User and Reference Guides
              for  more  information regarding the specific instruction
              sets covered by this notice.

              Notice revision #20110804

              = = = = = = = = = =

              Alternate Options:

              -mtune            Linux:  -mcpu  (this  is  a  deprecated
                                option)

                                OS X: None

       -multibyte-chars

       -no-multibyte-chars

              Determines whether multi-byte characters
                     are supported.

              Arguments:

              None

              Default:

              -multibyte-chars  Multi-byte characters are supported.

              Description:

              This option determines whether multi-byte characters  are
              supported.

              Alternate Options:

              None

       -multiple-processes[=n]

              Creates multiple processes that can be
                     used  to  compile large numbers of source files at
                     the same time.

              time. It can improve performance by reducing the time  it
              takes to compile source files on the command line.

              This  option  causes  the  compiler to create one or more
              copies of itself,  each  in  a  separate  process.  These
              copies simultaneously compile the source files.

              If  n is not specified for this option, the default value
              is as follows:

              · On Windows* systems, the value is based on the  setting
                of the NUMBER_OF_PROCESSORS environment variable.

              · On Linux* and OS X* systems, the value is 2.

              This  option  applies to compilations, but not to linking
              or link-time code generation.

              To override default heuristics, specify option /MP-force.
              It ensures that n will be the maximum number of processes
              created regardless of other heuristics that may limit the
              number of processes.

              Alternate Options:

              None

       -no-bss-init

              Tells  the  compiler  to  place  in  the DATA section any
              uninitialized variables and  explicitly  zero-initialized
              variables.

              Arguments:

              None

              Default:

              OFF               Uninitialized  variables and explicitly
                                zero-initialized variables  are  placed
                                in the BSS section.

              Description:

              This  option tells the compiler to place in the DATA sec-
              tion any uninitialized variables and explicitly zero-ini-
              tialized variables.

              Alternate Options:

              None

              This option prevents the linking of  certain gcc-specific
              libraries.

              This option is not recommended for general use.

              Alternate Options:

              None

       -nodefaultlibs

              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.

              Alternate Options:

              None

       -nolib-inline

              Disables inline expansion of standard library or  intrin-
              sic 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

              Default:

              OFF               The  compiler  uses  standard   startup
                                files when linking.

              Description:

              This  option  prevents  the  compiler from using standard
              startup files when linking.

              Alternate Options:

              None

       -nostdinc++

              Do not search for header files in the  standard  directo-
              ries  for C++, but search the other standard directories.

              Arguments:

              None

              Default:

              OFF

              Description:

              Do not search for header files in the  standard  directo-
              ries  for C++, but search the other standard directories.

              Alternate Options:

              None

       -nostdlib

              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 link-
                                ing.

              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 fol-
              lows:

              · If -c is specified, it specifies the name of the gener-
                ated object file.

              · If -S is specified, it specifies the name of the gener-
                ated assembly listing file.

              · If -P is specified, it specifies the name of the gener-
                ated preprocessor file.

              Otherwise, it specifies the name of the executable  file.

              Alternate Options:

              Linux and OS X: None

              Windows: /Fe

       -O[n]

              Specifies the code optimization for
                     applications.

              Arguments:

              n                 Is  the  optimization  level.  Possible
                                values are 1, 2, or 3. On Linux* and OS
                                X* 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.

                                determined  by  the compiler, depending
                                on which operating system and architec-
                                ture  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 architec-
                                ture  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 optimiza-
                                tion level.  Vectorization  is  enabled
                                at O2 and higher levels.

              On systems using IA-32 architecture: Some
                                basic  loop  optimizations such as Dis-
                                tribution, Predicate Opt,  Interchange,
                                multi-versioning,  and  scalar replace-
                                ments are performed.

              This option also enables:

                                · Inlining of intrinsics

                                · Intra-file interprocedural  optimiza-
                                  tion, which includes:

                                  · inlining

                                  · constant propagation
                                  · 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 vari-
                                    able 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.

              On Linux systems, 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).

              Many routines in the shared libraries are more
                                highly optimized for Intel(R) micropro-
                                cessors than for non-Intel microproces-
                                sors.

                                (Windows), the compiler  performs  more
                                aggressive   data  dependency  analysis
                                than for O2, which may result in longer
                                compilation times.

              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 optimiza-
                                tions.

              The               O3 option is recommended  for  applica-
                                tions  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) micropro-
                                cessors than for non-Intel microproces-
                                sors.

              The  last  O  option  specified on the command line takes
              precedence over any others.

       -Ofast

              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.

              It sets compiler options -O3, -no-prec-div, and -fp-model
              fast=2.

              On Linux* systems, this option is provided  for  compati-
              bility with gcc.

              Alternate Options:

              None
                                default.

              Description:

              This  option  enables  optimizations that do not increase
              code size; it produces smaller code size than O2. It dis-
              ables  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

              Compiles and links for function profiling
                     with gprof(1).

              Architecture Restrictions: Not available on  Intel(R)  64
              architecture targeting the
                     Intel(R) Xeon  Phi(TM)  coprocessor  x100  product
                     family  (formerly  code  name  Knights Corner), on
                     IA-32  architecture  targeting  Intel(R)  Graphics
                     Technology, or on Intel(R) 64 architecture target-
                     ing Intel(R) Graphics Technology

              Arguments:

              None

              Default:

              OFF               Files are compiled and  linked  without
                                profiling.

              Description:

              This  option  compiles  and  links for function profiling
              with gprof(1).

              When you specify this option, inlining is disabled.  How-
              ever, you can override this by specifying pragma forcein-
              line,   declspec   forceinline   (Windows*),    attribute
              always_inline  (Linux*  and  OS X*), or a compiler option
              such as [Q]inline-forceinline.

              Alternate Options:


              Description:

              This option tells the compiler to  stop  the  compilation
              process  after  C  or  C++ source files have been prepro-
              cessed 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  .i
              file  instead of stdout. Unlike the -E option, the output
              from -P on Linux does not  include  #line  number  direc-
              tives.  By  default, the preprocessor creates the name of
              the output file using the prefix of the source file  name
              with  a .i extension. You can change this by using the -o
              option.

              Alternate Options:

              Linux and OS X: -F

              Windows: None

       -parallel

              Tells the auto-parallelizer to generate
                     multithreaded code for loops that  can  be  safely
                     executed in parallel.

              Arguments:

              None

              Default:

              OFF               Multithreaded code is not generated for
                                loops that can be  safely  executed  in
                                parallel.

              Description:

              This  option tells the auto-parallelizer to generate mul-
              tithreaded code for loops that can be safely executed  in
              parallel.

              To  use  this  option, you must also specify option O2 or
              O3.

              This option sets option [q or Q]opt-matmul if  option  O3
              is also specified.

              NOTE:  On OS X* systems, when you enable automatic paral-


              = = = = = = = = = =

              Intel's compilers may or may not  optimize  to  the  same
              degree  for  non-Intel  microprocessors for optimizations
              that are not unique to Intel microprocessors. These opti-
              mizations  include SSE2, SSE3, and SSSE3 instruction sets
              and other optimizations. Intel  does  not  guarantee  the
              availability,  functionality,  or  effectiveness  of  any
              optimization  on  microprocessors  not  manufactured   by
              Intel.  Microprocessor-dependent  optimizations  in  this
              product are intended for use with Intel  microprocessors.
              Certain  optimizations  not specific to Intel microarchi-
              tecture are reserved for  Intel  microprocessors.  Please
              refer to the applicable product User and Reference Guides
              for more information regarding the  specific  instruction
              sets covered by this notice.

              Notice revision #20110804

              = = = = = = = = = =

              Alternate Options:

              None

       -parallel-source-info[=n]

       -no-parallel-source-info

              Enables or disables source location
                     emission when OpenMP* or auto-parallelism code  is
                     generated.

              Arguments:

              n                 Is  the  level of source location emis-
                                sion. Possible values are:

                                0              Disables the emission of
                                               source location informa-
                                               tion when  OpenMP*  code
                                               or auto-parallelism code
                                               is  generated.  This  is
                                               the  same  as specifying
                                               -no-parallel-source-info
                                               (Linux*  and  OS  X*) or
                                               /Qparallel-source-info-
                                               (Windows*).

                                1              Tells  the  compiler  to

              -parallel-source-info=1
                                When OpenMP* code  or  auto-parallelism
                                code is generated, the routine name and
                                line information is emitted.

              Description:

              This option enables or disables source location  emission
              when  OpenMP  code or auto-parallelism code is generated.
              It also lets you set the level of emission.

              Alternate Options:

              None

       -par-affinity=[modifier,...]type[,permute][,offset] (L*X only)

              Specifies thread affinity.

              Arguments:

              modifier          Is one of the following values:  granu-
                                larity={fine|thread|core}, [no]respect,
                                [no]verbose,     [no]warnings,     pro-
                                clist=proc_list.  The default is granu-
                                larity=core, respect, and noverbose.

              type              Indicates  the  thread  affinity.  This
                                argument is required and must be one of
                                the  following  values:  compact,  dis-
                                abled,  explicit,  none, scatter, logi-
                                cal, physical.  The  default  is  none.
                                Values  logical and physical are depre-
                                cated. Use compact and scatter, respec-
                                tively, with no permute value.

              permute           Is  a  positive integer. You cannot use
                                this   argument   with   type   setting
                                explicit,   none,   or   disabled.  The
                                default is 0.

              offset            Is a positive integer. You  cannot  use
                                this   argument   with   type   setting
                                explicit,  none,   or   disabled.   The
                                default is 0.

              Default:

              OFF               The  thread  affinity  is determined by
                                the run-time environment.

              Description:

              NOTE: This option  may  behave  differently  on  Intel(R)
              microprocessors than on non-Intel microprocessors.

              Alternate Options:

              None

       -par-num-threads=n

              Specifies  the  number  of  threads  to use in a parallel
              region.

              Arguments:

              n                 Is  the  number  of  threads to use. It
                                must be a positive integer.

              Default:

              OFF               The number of threads to use is  deter-
                                mined by the run-time environment.

              Description:

              This  option  specifies the number of threads to use in a
              parallel region. It has the same  effect  as  environment
              variable OMP_NUM_THREADS.

              This  option overrides the environment variable when both
              are specified.

              This option only has an effect if the following is true:

              · You have specified option [Q]parallel or option  [q  or
                Q]openmp (or both).

              · You are compiling the main program.

              Alternate Options:

              None

       -par-runtime-control[n]

       -no-par-runtime-control

              Generates code to perform run-time checks
                     for loops that have symbolic loop bounds.

              Arguments:

                                               code  under conservative
                                               mode.   This   is    the
                                               default  if  you  do not
                                               specify n.

                                2              Generates runtime  check
                                               code   under   heuristic
                                               mode.

                                3              Generates runtime  check
                                               code   under  aggressive
                                               mode.

              Default:

              -no-par-runtime-control
                                The compiler  uses  default  heuristics
                                when checking loops.

              Description:

              This option generates code to perform run-time checks for
              loops that have symbolic loop bounds.

              If the granularity of a loop is greater than  the  paral-
              lelization threshold, the loop will be executed in paral-
              lel.

              If you do not specify this option, the compiler  may  not
              parallelize  loops  with symbolic loop bounds if the com-
              pile-time granularity estimation of a loop can not ensure
              it is beneficial to parallelize the loop.

              NOTE:  This  option  may  behave  differently on Intel(R)
              microprocessors than on non-Intel microprocessors.

              Alternate Options:

              None

       -par-schedule-keyword[=n]

              Lets you specify a scheduling algorithm for  loop  itera-
              tions.

              Arguments:

              keyword           Specifies the scheduling  algorithm  or
                                tuning method. Possible values are:

                                auto           Lets   the  compiler  or
                                               run-time  system  deter-
                                               neighboring threads.

                                dynamic        Gets a set of iterations
                                               dynamically.

                                guided         Specifies a minimum num-
                                               ber of iterations.

                                guided-analytical
                                               Divides  iterations   by
                                               using  exponential  dis-
                                               tribution   or   dynamic
                                               distribution.

                                runtime        Defers   the  scheduling
                                               decision until run time.

              n                 Is  the size of the chunk or the number
                                of iterations for each chunk. This set-
                                ting  can only be specified for static,
                                dynamic, and guided. For more  informa-
                                tion, see the descriptions of each key-
                                word below.

              Default:

              static-balanced   Iterations are divided into  even-sized
                                chunks  and  the chunks are assigned to
                                the  threads   in   the   team   in   a
                                round-robin fashion in the order of the
                                thread number.

              Description:

              This option lets you specify a scheduling  algorithm  for
              loop  iterations.   It specifies how iterations are to be
              divided among the threads of the team.

              This option is only useful  when  specified  with  option
              [Q]parallel.

              This  option  affects  performance tuning and can provide
              better performance during auto-parallelization.  It  does
              nothing if it is used with option [q or Q]openmp.

              Option            Description

              [Q]par-schedule-auto
                                Lets  the  compiler  or run-time system
                                determine the scheduling algorithm. Any
                                possible  mapping  may occur for itera-
                                tions to threads in the team.

              [Q]par-schedule-static-balanced
                                Divides   iterations   into  even-sized
                                chunks. The chunks are assigned to  the
                                threads  in  the  team in a round-robin
                                fashion in the order of the thread num-
                                ber.

              [Q]par-schedule-static-steal
                                Divides   iterations   into  even-sized
                                chunks, but when a thread completes its
                                chunk,  it  can  steal  parts of chunks
                                assigned to neighboring threads.

              Each thread keeps track
                                of L and U, which represent  the  lower
                                and  upper bounds of its chunks respec-
                                tively.  Iterations are executed start-
                                ing  from the lower bound, and simulta-
                                neously, L is updated to represent  the
                                new lower bound.

              [Q]par-schedule-dynamic
                                Can  be used to get a set of iterations
                                dynamically.  Assigns   iterations   to
                                threads   in   chunks  as  the  threads
                                request them. The thread  executes  the
                                chunk   of  iterations,  then  requests
                                another chunk, until no  chunks  remain
                                to be assigned.

              As  each  thread finishes a piece of the iteration space,
              it dynamically gets the next
                                set  of iterations. Each chunk contains
                                n iterations, except for the last chunk
                                to  be  assigned,  which may have fewer
                                iterations. If no n is  specified,  the
                                default is 1.

              [Q]par-schedule-guided
                                Can be used to specify a minimum number
                                of iterations.  Assigns  iterations  to
                                threads   in   chunks  as  the  threads
                                request them. The thread  executes  the
                                chunk   of  iterations,  then  requests
                                another chunk, until no  chunks  remain
                                to be assigned.

              For  a chunk of size 1, the size of each chunk is propor-
              tional to the number of unassigned
                                iterations  divided  by  the  number of
                                threads, decreasing to 1.
                                The  method  depends on run-time imple-
                                mentation. Loop bounds  are  calculated
                                with  faster synchronization and chunks
                                are dynamically dispatched at run  time
                                by threads in the team.

              [Q]par-schedule-runtime
                                Defers  the  scheduling  decision until
                                run time. The scheduling algorithm  and
                                chunk size are then taken from the set-
                                ting of environment variable OMP_SCHED-
                                ULE.

              NOTE:  This  option  may  behave  differently on Intel(R)
              microprocessors than on non-Intel microprocessors.

              Alternate Options:

              None

       -par-threshold[n]

              Sets a threshold for the auto-parallelization of loops.

              Arguments:

              n                 Is  an  integer  whose  value  is   the
                                threshold  for the auto-parallelization
                                of loops. Possible values are 0 through
                                100.

                                If  n is 0, loops get auto-parallelized
                                always, regardless of computation  work
                                volume.

                                If  n  is  100,  loops  get auto-paral-
                                lelized when performance gains are pre-
                                dicted  based  on the compiler analysis
                                data. Loops get auto-parallelized  only
                                if  profitable  parallel  execution  is
                                almost certain.

                                The intermediate 1 to 99 values  repre-
                                sent  the  percentage  probability  for
                                profitable speed-up. For example,  n=50
                                directs  the  compiler  to  parallelize
                                only if there is a 50%  probability  of
                                the  code  speeding  up  if executed in
                                parallel.

              Default:

              old 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  may  behave  differently  on  Intel(R)
              microprocessors than on non-Intel microprocessors.

              Alternate Options:

              None

       -pcn

              Enables  control of floating-point significand precision.

              Arguments:

              n                 Is  the floating-point significand pre-
                                cision. Possible values are:

                                32             Rounds  the  significand
                                               to  24 bits (single pre-
                                               cision).

                                64             Rounds  the  significand
                                               to  53 bits (double pre-
                                               cision).

                                80             Rounds  the  significand
                                               to   64  bits  (extended
                                               precision).

              Default:

              -pc80             On Linux* and OS X* systems, the float-
                                ing-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 accu-
              racy of the significand, or fractional part of the float-
              ing-point  value.  For example, iterative operations like
              division and finding the square root can  run  faster  if
              you lower the precision with the this option.

              Arguments:

              None

              Default:

              OFF               The compiler does  not  create  or  use
                                precompiled  headers unless you tell it
                                to do so.

              Description:

              This option tells the compiler to use appropriate precom-
              piled header (PCH) files. If none are available, they are
              created as sourcefile.pchi. This option is supported  for
              multiple source files.

              The  -pch  option  will  use PCH files created from other
              sources if the headers files are the same.  For  example,
              if  you compile source1.cpp using -pch, then source1.pchi
              is created.  If you then compile source2.cpp using  -pch,
              the compiler will use source1.pchi if it detects the same
              headers.

              CAUTION: Depending on how you organize the  header  files
              listed  in your sources, this option may increase compile
              times.

              Alternate Options:

              None

       -pch-create
              filename

              Tells the compiler to create a
                     precompiled header file.

              Arguments:

              filename          Is the name for the precompiled  header
                                file.  A  space  must appear before the
                                file name. It can include a path.

              Default:

              OFF               The compiler does  not  create  or  use
                                precompiled  headers unless you tell it
                                to do so.

              Description:
              Alternate Options:

              Linux and OS X: None

              Windows: /Yc

       -pch-dir dir

              Tells  the  compiler  the location for precompiled header
              files.

              Arguments:

              dir               Is  the  path  for  precompiled  header
                                files. The path must exist.

              Default:

              OFF               The compiler does  not  create  or  use
                                precompiled  headers unless you tell it
                                to do so.

              Description:

              This option tells the compiler the location  for  precom-
              piled header files.  It denotes where to find precompiled
              header files, and where new PCH files should be placed.

              This option can be used with the -pch,  -pch-create,  and
              -pch-use options.

              Alternate Options:

              None

       -pch-use
              filename

              Tells the compiler to use a precompiled
                     header file.

              Arguments:

              filename          Is  the  name of the precompiled header
                                file  to  use.   A  space  must  appear
                                before  the file name. It can include a
                                path.

              Default:

              OFF               The compiler does  not  create  or  use
                                precompiled  headers unless you tell it

              options, see "Using  Precompiled  Header  Files"  in  the
              User's Guide.

              On Windows* systems, option -pch-use is equivalent to the
              /Yu option.

              Alternate Options:

              Linux and OS X: None

              Windows: /Yu

       -pie

       -no-pie

              Determines whether the compiler
                     generates position-independent code that  will  be
                     linked into an executable.

              Arguments:

              None

              Default:

              varies            On  Linux*  and  on OS X* versions less
                                than 10.7, the default is  -no-pie.  On
                                OS  X*  10.7 or greater, the default is
                                -pie.

              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

              Specifies  which interpretation of the optimization_level
              pragma should be used if no prefix is specified.

              Arguments:
                                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.

              Alternate Options:

              None

       -prec-div

       -no-prec-div

              Improves precision of floating-point
                     divides.

              Arguments:

              None

              Default:

              -prec-div         The   compiler  uses  this  method  for
                                floating-point divides.

              Description:

              This option improves precision of floating-point divides.
              It has a slight impact on speed.

              With  some  optimizations,  such  as  -msse2  (Linux*) or
              /arch:SSE2 (Windows*), the  compiler  may  change  float-
              ing-point  division  computations  into multiplication by
              the reciprocal of the denominator. For  example,  A/B  is
              computed  as A * (1/B) to improve the speed of the compu-
              tation.

              However, sometimes the value produced by this transforma-
              tion is not as accurate as full IEEE division. When it is
              important to have fully precise IEEE division,  use  this
              option  to  disable the floating-point division-to-multi-
              plication optimization. The result is more accurate, with
              some loss of performance.

              If  you  specify  -no-prec-div  (Linux*  and  OS  X*)  or
              /Qprec-div- (Windows*),  it  enables  optimizations  that
              give  slightly  less precise results than full IEEE divi-
              sion.

              Default:

              -no-prec-sqrt     The compiler uses  a  faster  but  less
                                precise  implementation of square root.

                                However, the default is  -prec-sqrt  if
                                any of the following options are speci-
                                fied: -O0  or -mp1 on Linux* and OS  X*
                                systems.

              Description:

              This option improves precision of square root implementa-
              tions. It has a slight impact on speed.

              This option inhibits any optimizations that can adversely
              affect  the  precision  of a square root computation. The
              result is fully precise square root implementations, with
              some loss of performance.

              Alternate Options:

              None

       -print-multi-lib

              Prints information about where system
                     libraries should be found.

              Architecture  Restrictions:  Not available on Intel(R) 64
              architecture targeting the
                     Intel(R)  Xeon  Phi(TM)  coprocessor  x100 product
                     family (formerly code name Knights Corner)

              Arguments:

              None

              Default:

              OFF               No information is  printed  unless  the
                                option is specified.

              Description:

              This   option   prints  information  about  where  system
              libraries should be found, but no compilation occurs.  On
              Linux*  systems,  it  is  provided for compatibility with
              gcc.

              Alternate Options:

              Arguments:

              None

              Default:

              OFF               Nothing is printed.

              Description:

              This  option  prints the target sysroot directory that is
              used during compilation.

              This is the target sysroot directory that is specified in
              an  environment  file or in option --sysroot. This option
              is only effective if a target sysroot has been specified.

              This option is provided for compatibility with gcc.

              NOTE: Even though this option is not supported for a Win-
              dows-to-Windows native compiler, it is  supported  for  a
              Windows-host to Linux-target compiler.

              Alternate Options:

              None

       -prof-data-order (L*X only)

       -no-prof-data-order (L*X only)

              Enables or disables data ordering if
                     profiling information is enabled.

              Architecture  Restrictions:  Not available on Intel(R) 64
              architecture targeting the
                     Intel(R)  Xeon  Phi(TM)  coprocessor  x100 product
                     family (formerly code  name  Knights  Corner),  on
                     IA-32  architecture  targeting  Intel(R)  Graphics
                     Technology, or on Intel(R) 64 architecture target-
                     ing Intel(R) Graphics Technology

              Arguments:

              None

              Default:

              -no-prof-data-order
                                Data ordering is disabled.

              Description:
                [Q]ipo-c.

              Alternate Options:

              None

       -prof-dir
              dir

              Specifies a directory for profiling
                     information output files.

              Architecture Restrictions: Not available on  Intel(R)  64
              architecture targeting the
                     Intel(R) Xeon  Phi(TM)  coprocessor  x100  product
                     family  (formerly  code  name  Knights Corner), on
                     IA-32  architecture  targeting  Intel(R)  Graphics
                     Technology, or on Intel(R) 64 architecture target-
                     ing Intel(R) Graphics Technology

              Arguments:

              dir               Is the name of the directory.  You  can
                                specify a relative pathname or an abso-
                                lute pathname.

              Default:

              OFF               Profiling output files  are  placed  in
                                the directory where the program is com-
                                piled.

              Description:

              This option specifies a directory for profiling  informa-
              tion output files (*.dyn and *.dpi). The specified direc-
              tory must already exist.

              You should specify this option using the  same  directory
              name  for both instrumentation and feedback compilations.
              If you move the .dyn files, you need to specify  the  new
              path.

              Option  /Qprof-dir  is equivalent to option /Qcov-dir. If
              you specify both options, the last  option  specified  on
              the command line takes precedence.

              Alternate Options:

              None

       -prof-file

              filename          Is  the  name  of the profiling summary
                                file.

              Default:

              OFF               The profiling summary  files  have  the
                                file name pgopti.*

              Description:

              This option specifies an alternate file name for the pro-
              filing summary files. The filename is used  as  the  base
              name for files created by different profiling passes.

              If  you  add this option to profmerge, the .dpi file will
              be named filename.dpi instead of pgopti.dpi.

              If you specify this option with option  [Q]prof-use,  the
              .dpi   file   will   be  named  filename.dpi  instead  of
              pgopti.dpi.

              Option /Qprof-file is equivalent to option /Qcov-file. If
              you  specify  both  options, the last option specified on
              the command line takes precedence.

              NOTE: When you use  option  [Q]prof-file,  you  can  only
              specify a file name. If you want to specify a path (rela-
              tive or absolute) for filename, you must also use  option
              [Q]prof-dir.

              Alternate Options:

              None

       -prof-func-groups (L*X only)

       -no-prof-func-groups (L*X only)

              Enables or disables function grouping if
                     profiling information is enabled.

              Architecture  Restrictions:  Not available on Intel(R) 64
              architecture targeting the
                     Intel(R)  Xeon  Phi(TM)  coprocessor  x100 product
                     family (formerly code  name  Knights  Corner),  on
                     IA-32  architecture  targeting  Intel(R)  Graphics
                     Technology, or on Intel(R) 64 architecture target-
                     ing Intel(R) Graphics Technology

              Arguments:

              section or the hot code section.

              If profiling information is enabled by option  -prof-use,
              option  -prof-func-groups is set and function grouping is
              enabled.    However,    if    you    explicitly    enable
              -prof-func-order,  function ordering is performed instead
              of function grouping.

              If you want to disable function grouping  when  profiling
              information is enabled, specify -no-prof-func-groups.

              To  set  the hotness threshold for function grouping, use
              option -prof-hotness-threshold.

       -prof-func-order (L*X only)

       -no-prof-func-order (L*X only)

              Enables or disables function ordering if
                     profiling information is enabled.

              Architecture Restrictions: Not available on  Intel(R)  64
              architecture targeting the
                     Intel(R) Xeon  Phi(TM)  coprocessor  x100  product
                     family (formerly code name Knights Corner)

              Arguments:

              None

              Default:

              -no-prof-func-order
                                Function ordering is disabled.

              Description:

              This option enables or disables function ordering if pro-
              filing information is enabled.

              For this option to be effective, you must do the  follow-
              ing:

              · For   instrumentation  compilation,  you  must  specify
                option [Q]prof-gen setting srcpos.

              · For feedback compilation, you must specify [Q]prof-use.
                You  must not use multi-file optimization by specifying
                options such as [Q]ipo or [Q]ipo-c.

              If you enable profiling information by specifying  option
              [Q]prof-use,  option [Q]prof-func-groups is set and func-

       -prof-gen[=keyword[,
              keyword],...]

       -no-prof-gen

              Produces an instrumented object file that
                     can be used in profile guided optimization.

              Architecture  Restrictions: Not available on IA-32 archi-
              tecture targeting Intel(R)
                     Graphics  Technology,  or on Intel(R) 64 architec-
                     ture targeting Intel(R) Graphics Technology

              Arguments:

              keyword           Specifies details for the  instrumented
                                file.  Possible values are:

                                default        Produces an instrumented
                                               object file. This is the
                                               same  as  specifying the
                                               [Q]prof-gen option  with
                                               no keyword.

                                srcpos         Produces an instrumented
                                               object     file     that
                                               includes   extra  source
                                               position information.

                                globdata       Produces an instrumented
                                               object     file     that
                                               includes information for
                                               global data layout.

                                [no]threadsafe Produces an instrumented
                                               object     file     that
                                               includes  the collection
                                               of PGO data on  applica-
                                               tions  that  use  a high
                                               level of parallelism. If
                                               [Q]prof-gen is specified
                                               with  no  keyword,   the
                                               default is nothreadsafe.

                                               On Intel(R) 64 architec-
                                               ture    targeting    the
                                               Intel(R)  Xeon   Phi(TM)
                                               coprocessor x100 product
                                               family  (formerly   code
                                               name   Knights  Corner),
                                               the only valid  mode  is
                                               keyword threadsafe.

              –prof-gen=scrpos -prof-gen=threadsafe (Linux* and OS X*)
              -prof-gen=scrpos,  threadsafe  (this is equivalent to the
              above)


              /Qprof-gen:scrpos    /Qprof-gen:threadsafe     (Windows*)
              /Qprof-gen:scrpos,  threadsafe (this is equivalent to the
              above)


              If you specify keyword srcpos or globdata, a static  pro-
              file  information  file (.spi) is created. These settings
              may increase the time needed to do a parallel build using
              -prof-gen, because of contention writing the .spi file.

              These  options  are used in phase 1 of the Profile Guided
              Optimizer (PGO)  to  instruct  the  compiler  to  produce
              instrumented code in your object files in preparation for
              instrumented execution.

              When the [Q]prof-gen option is used to produce an instru-
              mented binary file for profile generation, some optimiza-
              tions are disabled. Those optimizations are not  disabled
              for any subsequent profile-guided compilation with option
              [Q]prof-use that makes use of the generated profiles.

              Alternate Options:

              None

       -prof-hotness-threshold=n (L*X only)

              Lets you set the hotness threshold for
                     function grouping and function ordering.

              Architecture Restrictions: Not available on  Intel(R)  64
              architecture targeting the
                     Intel(R) Xeon  Phi(TM)  coprocessor  x100  product
                     family  (formerly  code  name  Knights Corner), on
                     IA-32  architecture  targeting  Intel(R)  Graphics
                     Technology, or on Intel(R) 64 architecture target-
                     ing Intel(R) Graphics Technology

              Arguments:

              n                 Is the hotness threshold.  n is a  per-
                                centage  having  a  value between 0 and
                                100 inclusive. If you specify 0,  there
                                will be no hotness threshold setting in
                                effect for function grouping and  func-
                                tion ordering.

              tion's  hot region. The hot region is the most frequently
              executed part of the application. By grouping these func-
              tions  together  into one hot region, they have a greater
              probability of  remaining  resident  in  the  instruction
              cache. This can enhance the application's performance.

              For  this  option to take effect, you must specify option
              [Q]prof-use and one of the following:

              · On Linux systems: -prof-func-groups or -prof-func-order

              · On Windows systems: /Qprof-func-order

              Alternate Options:

              None

       -prof-src-dir

       -no-prof-src-dir

              Determines whether directory information
                     of the source file under compilation is considered
                     when looking up profile data records.

              Architecture Restrictions: Not available on  Intel(R)  64
              architecture targeting the
                     Intel(R) Xeon  Phi(TM)  coprocessor  x100  product
                     family  (formerly  code  name  Knights Corner), on
                     IA-32  architecture  targeting  Intel(R)  Graphics
                     Technology, or on Intel(R) 64 architecture target-
                     ing Intel(R) Graphics Technology

              Arguments:

              None

              Default:

              prof-src-dir      Directory  information  is  used   when
                                looking  up profile data records in the
                                .dpi file.

              Description:

              This option determines whether directory  information  of
              the  source  file  under  compilation  is considered when
              looking up profile data records in the .dpi file. To  use
              this  option,  you  must  also  specify  the  [Q]prof-use
              option.

              If the option is enabled, directory information  is  con-
              .dyn or [Q]prof-dir specifies the location of the .dyn or
              the .dpi files.

              Alternate Options:

              None

       -prof-src-root=dir

              Lets you use relative directory paths
                     when looking  up  profile  data  and  specifies  a
                     directory as the base.

              Architecture  Restrictions:  Not available on Intel(R) 64
              architecture targeting the
                     Intel(R)  Xeon  Phi(TM)  coprocessor  x100 product
                     family (formerly code  name  Knights  Corner),  on
                     IA-32  architecture  targeting  Intel(R)  Graphics
                     Technology, or on Intel(R) 64 architecture target-
                     ing Intel(R) Graphics Technology

              Arguments:

              dir               Is the base for the relative paths.

              Default:

              OFF               The  setting of relevant options deter-
                                mines the path  used  when  looking  up
                                profile data records.

              Description:

              This  option  lets  you use relative directory paths when
              looking up profile data in .dpi files. It lets you  spec-
              ify  a directory as the base. The paths are relative to a
              base directory specified during the [Q]prof-gen  compila-
              tion phase.

              This  option  is available during the following phases of
              compilation:

              · Linux* and  OS  X*  systems:  -prof-gen  and  -prof-use
                phases

              · Windows* systems: /Qprof-gen and /Qprof-use phases

              When  this  option  is  specified  during the [Q]prof-gen
              phase, it stores information into the .dyn or .dpi  file.
              Then,  when  .dyn  files  are merged together or the .dpi
              file is loaded, only the directory information below  the
              root directory is used for forming the lookup key.
              None

       -prof-src-root-cwd

              Lets you use relative directory paths
                     when looking up profile  data  and  specifies  the
                     current working directory as the base.

              Architecture  Restrictions:  Not available on Intel(R) 64
              architecture targeting the
                     Intel(R)  Xeon  Phi(TM)  coprocessor  x100 product
                     family (formerly code  name  Knights  Corner),  on
                     IA-32  architecture  targeting  Intel(R)  Graphics
                     Technology, or on Intel(R) 64 architecture target-
                     ing Intel(R) Graphics Technology

              Arguments:

              None

              Default:

              OFF               The  setting of relevant options deter-
                                mines the path  used  when  looking  up
                                profile data records.

              Description:

              This  option  lets  you use relative directory paths when
              looking up profile data in .dpi files. It  specifies  the
              current  working  directory  as  the  base.  To  use this
              option, you must also specify option [Q]prof-use.

              This option is available during the following  phases  of
              compilation:

              · Linux*  and  OS  X*  systems:  -prof-gen  and -prof-use
                phases

              · Windows* systems: /Qprof-gen and /Qprof-use phases

              When this option  is  specified  during  the  [Q]prof-gen
              phase,  it stores information into the .dyn or .dpi file.
              Then, when .dyn files are merged  together  or  the  .dpi
              file  is loaded, only the directory information below the
              root directory is used for forming the lookup key.

              When this option  is  specified  during  the  [Q]prof-use
              phase,  it  specifies  a root directory that replaces the
              root directory specified at  the  [Q]prof-gen  phase  for
              forming the lookup keys.

                     during optimization.

              Architecture Restrictions: Not available on  Intel(R)  64
              architecture targeting the
                     Intel(R) Xeon  Phi(TM)  coprocessor  x100  product
                     family  (formerly  code  name  Knights Corner), on
                     IA-32  architecture  targeting  Intel(R)  Graphics
                     Technology, or on Intel(R) 64 architecture target-
                     ing Intel(R) Graphics Technology

              Arguments:

              keyword           Specifies additional instructions. Pos-
                                sible values are:

                                weighted       Tells    the   profmerge
                                               utility   to   apply   a
                                               weighting  to  the  .dyn
                                               file values when  creat-
                                               ing  the  .dpi  file  to
                                               normalize    the    data
                                               counts when the training
                                               runs have  differentexe-
                                               cution  durations.  This
                                               argument  only  has   an
                                               effect when the compiler
                                               invokes  the   profmerge
                                               utility  to  create  the
                                               .dpi file. This argument
                                               does  not have an effect
                                               if  the  .dpi  file  was
                                               previously created with-
                                               out weighting.

                                [no]merge      Enables   or    disables
                                               automatic  invocation of
                                               the  profmerge  utility.
                                               The  default  is  merge.
                                               Note  that  you   cannot
                                               specify   both  weighted
                                               and nomerge. If you  try
                                               to  specify both values,
                                               a warning will  be  dis-
                                               played and nomerge takes
                                               precedence.

                                default        Enables the use of  pro-
                                               filing  information dur-
                                               ing  optimization.   The
                                               profmerge   utility   is
                                               invoked by default. This
                                               value  is  the  same  as

              This  option  instructs  the  compiler  to produce a pro-
              file-optimized executable and it merges available profil-
              ing output files into a pgopti.dpi file.

              Note  that  there is no way to turn off function grouping
              if you enable it using this option.

              To set the hotness threshold for  function  grouping  and
              function  ordering, use option [Q]prof-hotness-threshold.

              Alternate Options:

              None

       -prof-value-profiling[=keyword]

              Controls which values are value profiled.

              Architecture Restrictions: Not available on  Intel(R)  64
              architecture targeting the
                     Intel(R) Xeon  Phi(TM)  coprocessor  x100  product
                     family  (formerly  code  name  Knights Corner), on
                     IA-32  architecture  targeting  Intel(R)  Graphics
                     Technology, or on Intel(R) 64 architecture target-
                     ing Intel(R) Graphics Technology

              Arguments:

              keyword           Controls which type of value  profiling
                                is performed. Possible values are:

                                none           Prevents  all  types  of
                                               value profiling.

                                nodivide       Prevents value profiling
                                               of non-compile time con-
                                               stants used in  division
                                               or remainder operations.

                                noindcall      Prevents value profiling
                                               of function addresses at
                                               indirect call sites.

                                all            Enables  all  types   of
                                               value profiling.

              You  can  specify more than one keyword, but they must be
              separated by commas.

              Default:

              all               All value profile types are enabled and

              If  you  specify  level  2  or  higher  for  option[q  or
              Q]opt-report, the value profiling specialization informa-
              tion will be reported within the PGO optimization report.

              Alternate Options:

              None

       -profile-functions

              Inserts instrumentation calls at a
                     function's entry and exit points.

              Architecture  Restrictions:  Not available on Intel(R) 64
              architecture targeting the
                     Intel(R)  Xeon  Phi(TM)  coprocessor  x100 product
                     family (formerly code  name  Knights  Corner),  on
                     IA-32  architecture  targeting  Intel(R)  Graphics
                     Technology, or on Intel(R) 64 architecture target-
                     ing Intel(R) Graphics Technology

              Arguments:

              None

              Default:

              OFF               No  instrumentation  calls are inserted
                                at a function's entry and exit  points.

              Description:

              This option inserts instrumentation calls at a function's
              entry and exit points within a  single-threaded  applica-
              tion  to  collect the cycles spent within the function to
              produce  reports  that  can  help  in  identifying   code
              hotspots.

              When  the  instrumented  application  is run, this option
              causes the generation  of  a  loop_prof_funcs_<name>.dump
              file, where <name> is a timestamp for the run.

              The  same  data  values  are  also  dumped  into the file
              loop_prof_<name>.xml for use with the data viewer  appli-
              cation,  unless you turn off the output format by setting
              the environment variable INTEL_LOOP_PROF_XML_DUMP to 0.

              Alternate Options:

              None

              Arguments:

              keyword           Specifies  which  type  of loops should
                                have instrumentation.  Possible  values
                                are:

                                inner          Inserts  instrumentation
                                               before and  after  inner
                                               loops.

                                outer          Inserts  instrumentation
                                               before and  after  outer
                                               loops.

                                all            Inserts  instrumentation
                                               before  and  after   all
                                               loops.

              Default:

              OFF               No  instrumentation  calls are inserted
                                at a function's entry and exit  points,
                                or   before  and  after  instrumentable
                                loop.

              Description:

              This option inserts instrumentation calls at a function's
              entry  and  exit points within a single-threaded applica-
              tion.  For  unthreaded  applications,  it  also   inserts
              instrumentation  before and after instrumentable loops of
              the type listed in keyword.

              When the instrumented application  is  run,  this  option
              causes  the  generation  of a loop_prof_funcs_<name>.dump
              file and a loop_prof_funcs_<name>.dump file, where <name>
              is a timestamp for the run.

              The same timestamp is used for the loop file and function
              file. This identifies that the  loop  data  and  function
              data were from the same program run.

              The  same  data  values  are  also  dumped  into the file
              loop_prof_<name>.xml for use with the data viewer  appli-
              cation,  unless you turn off the output format by setting
              the environment variable INTEL_LOOP_PROF_XML_DUMP to 0.

              Alternate Options:

              None

       -profile-loops-report[=n]

              n                 Is a value denoting the level of detail
                                to report.  Possible values are:

                                1              Reports the cycle counts
                                               on  entry  and  exits of
                                               loops.   This   is   the
                                               default   if  n  is  not
                                               specified.

                                2              Reports  the   level   1
                                               default   details,   but
                                               also includes  the  loop
                                               min/max and average loop
                                               iteration counts.

                                               To  collect   the   loop
                                               iteration  counts, addi-
                                               tional   instrumentation
                                               is  inserted.  This  can
                                               increase overhead in the
                                               instrumented application
                                               and slow performance.

              Default:

              1                 The report shows the  cycle  counts  on
                                entry and exits of loops.

              Description:

              This  option  controls  the  level of detail for the data
              collected when instrumentation occurs  before  and  after
              certain  loops. To use this option, you must also specify
              option [Q]profile-loops.

              The report appears in  file  loop_prof_loops_<name>.dump,
              where  <name>  is  a  timestamp  value  for  the run. The
              columns listed in the report will be based on  the  level
              of detail that was selected during instrumentation.

              It  is recommended that the same report level be used for
              all files that are instrumented for the  application.  If
              different files of the application were instrumented with
              different levels, the report will contain all the columns
              of  the highest detail level, but with default values for
              unavailable fields for files that  were  instrumented  at
              lower levels.

              Alternate Options:

              None

              Description:

              Tells the compiler to use  pthreads  library  for  multi-
              threading support.

              Alternate Options:

              None

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

       -qno-offload (L*X only)

              Lets you specify the mode for offloading
                     or tell the compiler to ignore language constructs
                     for  offloading.  This  option  only  applies   to
                     Intel(R) MIC Architecture.  Options /Qoffload- and
                     /Qoffload:none are  also  available  for  Intel(R)
                     Graphics  Technology. Option -q[no-]offload is the
                     replacement option  for  -[no-]offload,  which  is
                     deprecated.

              Architecture   Restrictions:   Keywords   mandatory   and
              optional: Only
                     available  on  Intel(R)  64 architecture targeting
                     Intel(R) MIC  Architecture  /Qoffload-  and  /Qof-
                     fload:none:  Only  available on Intel(R) 64 archi-
                     tecture targeting Intel(R)  MIC  Architecture,  on
                     IA-32  architecture  targeting  Intel(R)  Graphics
                     Technology, or on Intel(R) 64 architecture target-
                     ing Intel(R) Graphics Technology

              Arguments:

              keyword           Specifies the mode for offloading or it
                                disables  offloading.  Possible  values
                                are:

                                none           Tells  the  compiler  to
                                               ignore   language   con-
                                               structs  for offloading.
                                               Warnings are  issued  by
                                               the  compiler.  This  is
                                               equivalent to the  nega-
                                               tive form of the option.

                                mandatory      Specifies that  offload-
                                               ing     is     mandatory
                                               (required). If the  tar-
                                               get  is  not  available,
                                               one  of  the   following
                                               ing      is     optional
                                               (requested). If the tar-
                                               get  is  not  available,
                                               the program is  executed
                                               on the CPU, not the tar-
                                               get.

              Default:

              mandatory         The compiler recognizes  language  con-
                                structs  for  offloading  if  they  are
                                specified. If option -qoffload (Linux*)
                                or  /Qoffload  (Windows*)  is specified
                                with no keyword, the default is  manda-
                                tory.

              Description:

              This  option  lets you specify the mode for offloading or
              tell the  compiler  to  ignore  language  constructs  for
              offloading.

              Option  -q[no-]offload  is  the  replacement  option  for
              -[no-]offload, which is deprecated.

              On Intel(R) Graphics Technology, the only options you can
              specify are /Qoffload- or /Qoffload:none, which tells the
              compiler to ignore language constructs for offloading. By
              default,  offloading  is  optional  for Intel(R) Graphics
              Technology.

              If no -qoffload (Linux*) or /Qoffload  (Windows*)  option
              appears  on  the  command  line, then offload pragmas are
              processed and:

              · The mandatory or optional clauses are obeyed if present

              · If  no  mandatory  or  optional  clause is present, the
                offload is mandatory

              If any of the following appears on the command line, then
              offload pragmas are ignored:

              · Linux* systems: -qoffload=none or -qno-offload

              · Windows* systems: /offload:none or /Qoffload-

              However,  OpenMP*  pragmas  for  coprocessor control (for
              example, omp target) are recognized if the [q or Q]openmp
              option is specified, regardless of whether or not offload
              pragmas are recognized or ignored.

              Alternate Options:

              None

       -qoffload-arch=arch[:visa] (L*X only)

              Lets you specify the target architecture
                     to use when  offloading  code.  This  option  only
                     applies  to Intel(R) MIC Architecture and Intel(R)
                     Graphics Technology.  For Intel(R) Graphics  Tech-
                     nology, you can also specify a virtual ISA (vISA).

              Architecture Restrictions: Only available on Intel(R)  64
              architecture targeting Intel(R)
                     MIC Architecture, on IA-32 architecture  targeting
                     Intel(R)  Graphics  Technology,  or on Intel(R) 64
                     architecture targeting Intel(R) Graphics  Technol-
                     ogy

              Arguments:

              arch              Specifies the target architecture.

                                On  Intel(R)  64 architecture targeting
                                Intel(R) MIC Architecture, arch can  be
                                one of the following:

                                · mic,   targeting  the  Intel(R)  Xeon
                                  Phi(TM) coprocessor x100 product fam-
                                  ily  (formerly code name Knights Cor-
                                  ner)

                                · mic-avx512,  targeting  the  Intel(R)
                                  Xeon  Phi(TM)  coprocessor (code name
                                  Knights Landing)

                                On IA-32 and Intel(R) 64  architectures
                                targeting Intel(R) Graphics Technology,
                                arch can be  haswell,  broadwell,  sky-
                                lake, or broxton.

              visa              Specifies  the  virtual ISA (vISA) ver-
                                sion to be used.

                                This optional argument is only  allowed
                                on  IA-32 and Intel(R) 64 architectures
                                targeting Intel(R) Graphics Technology.
                                You   can   only   specify  visa3.1  or
                                visa3.2.

              Default:

              On IA-32 and Intel(R) 64 architectures targeting Intel(R)
              Graphics  Technology,  the  compiler  will check that the
              values specified for arch and visa  are  compatible.  For
              architectures where multiple vISA versions are supported,
              the vISA version selected must be  <=  the  vISA  version
              supported by the driver installed on the system where the
              application is to be executed.

              The following table shows the vISA version that each arch
              supports:

              The  following  are  various combinations and settings of
              command line options for offloading:

              · Offload: Intel(R) 64  architecture  host  and  Intel(R)
                Xeon  Phi(TM) coprocessor x100 product family (formerly
                code name Knights Corner) target code generation:

                icc …                         ! default for Linux  icc
                … -qoffload-arch=mic      ! explicit KNC for Linux icl
                …                         ! default for Windows icl …
                /Qoffload-arch=mic      ! explicit KNC for Windows

              · Offload:  Intel(R)  64  architecture  host and Intel(R)
                Xeon Phi(TM) coprocessor (code  name  Knights  Landing)
                target code generation:

                icc   …  -qoffload-arch=mic-avx512      ! Linux icl …
                /Qoffload-arch=mic-avx512     ! Windows

              · Offload : Intel(R) Xeon Phi(TM) coprocessor (code  name
                Knights  Landing)  host and target code generation (for
                this host, target defaults  to  Intel(R)  Xeon  Phi(TM)
                coprocessor (code name Knights Landing)):

                icc   … -xmic-avx512      ! Linux icl … /Qxmic-avx512
                ! Windows

              · Native : Code  Generation  for  Intel(R)  Xeon  Phi(TM)
                coprocessor  x100  product  family  (formerly code name
                Knights Corner):

                icc   …  -mmic              !  Linux  icl   …   /Qmic
                ! Windows

              · Native  :  Code  Generation  for  Intel(R) Xeon Phi(TM)
                coprocessor (code name Knights Landing):

                icc … -xmic-avx512 –qno-offload     ! Linux  icl   …
                /Qxmic-avx512 /Qno-offload    ! Windows

              Alternate Options:
              Architecture  Restrictions: Only available on Intel(R) 64
              architecture targeting Intel(R)
                     MIC  Architecture, on IA-32 architecture targeting
                     Intel(R) Graphics Technology, or  on  Intel(R)  64
                     architecture  targeting Intel(R) Graphics Technol-
                     ogy

              Arguments:

              target-name       Is a specific  target  or  application.
                                The  supported values for this argument
                                are:

                                · mic for Intel(R) MIC Architecture

                                · gfx for Intel(R) Graphics Technology

              Default:

              OFF               The compiler does not  flag  file-scope
                                functions   and  data  objects  in  the
                                source file with the offload  attribute
                                target(mic) or target(gfx).

              Description:

              This  option causes the compiler to flag file-scope func-
              tions and data  objects  in  the  source  file  with  the
              offload attribute target(mic) or target(gfx).

              This    option   is   similar   to   using   the   pragma
              offload_attribute target(mic) to set the  attribute  tar-
              get(mic),  or  offload_attribute  target(gfx)  to set the
              attribute target(gfx), for all functions and data objects
              in the file scope.

              Target  declspecs/attributes  on  individual declarations
              take precedence  over  any  offload_attribute  pragma  in
              effect,  and  declspecs, attributes, and pragmas all take
              precedence over this option.

              Alternate Options:

              None

       -qoffload-option,target,tool,"option-list" (L*X only)

              Lets you explicitly specify options to be
                     used for  the  specified  target  and  tool.  This
                     option  only  applies to Intel(R) MIC Architecture
                     and Intel(R)  Graphics  Technology.  Option  -qof-
                     fload-option   is   the   replacement  option  for

                                · mic for Intel(R) MIC Architecture

                                · gfx for Intel(R) Graphics Technology

              tool              Is  the  tool  that  the option-list is
                                associated with. It can be one  of  the
                                following values: ld, link, as, or com-
                                piler.

                                ld is the linker tool on  Linux*;  link
                                is the linker tool on Windows*.

              option-list       Is  one  or  more options that are spe-
                                cific to the tool. The  quotation  mark
                                delimiters are required. Each option in
                                the option-list must be separated by  a
                                space.

                                For  tool  compiler,  use compiler-spe-
                                cific  options;  for   tool   ld,   use
                                linker-specific  options;  for tool as,
                                use  assembler-specific  options.   The
                                options  for  the  tools always use the
                                Linux form even when compiling on  Win-
                                dows.

              Default:

              OFF               The  compiler  does not pass additional
                                options to the separate  tools  on  the
                                target architecture.

              Description:

              This  option  lets  you  explicitly specify options to be
              used for the specified target and tool. It can be  speci-
              fied multiple times on the command line.

              When  building  a  heterogeneous  application, the driver
              passes all compiler options specified on the command-line
              to  the  host compilation and only certain options to the
              offload compilation. To see a list of options  passed  to
              the offload compilation, specify option watch=mic-cmd.

              If  you  want  to  pass additional options to the offload
              compilation, or you would like to  override  the  command
              line  options passed to offload compilation, you must use
              option [q or Q]offload-option to specify  the  additional
              or overriding options.

              NOTE:  If  you specify the options I, L, D, or U with the

       -qoffload-svm (L*X only)

       -qno-offload-svm (L*X only)

              Determines  whether the compiler uses Shared Virtual Mem-
              ory (SVM) mode.  This option  only  applies  to  Intel(R)
              Graphics Technology.

              Architecture Restrictions: Only available on IA-32 archi-
              tecture targeting Intel(R)  Graphics  Technology,  or  on
              Intel(R)  64  architecture  targeting  Intel(R)  Graphics
              Technology

              Arguments:

              None

              Default:

              -qno-offload-svm or /Qoffload-svm-
                                The compiler does not use SVM mode.

              Description:

              This  option  determines whether the compiler uses Shared
              Virtual  Memory  (SVM)  mode.  When  you  specify  [q  or
              Q]offload-svm,  virtual  address  space is shared between
              the CPU and the architecture targeting Intel(R)  Graphics
              Technology.

              Alternate Options:

              None

       -qopenmp

       -qno-openmp

              Enables the parallelizer to generate
                     multi-threaded  code  based on OpenMP* directives.
                     Option -qopenmp  is  the  replacement  option  for
                     -openmp, which is deprecated.

              Arguments:

              None

              Default:

              -qno-openmp       No  OpenMP* multi-threaded code is gen-
                                erated by the compiler.

              within Xcode* or an error will be displayed.

              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.


              Optimization Notice


              = = = = = = = = = =

              Intel's  compilers  may  or  may not optimize to the same
              degree for non-Intel  microprocessors  for  optimizations
              that are not unique to Intel microprocessors. These opti-
              mizations include SSE2, SSE3, and SSSE3 instruction  sets
              and  other  optimizations.  Intel  does not guarantee the
              availability,  functionality,  or  effectiveness  of  any
              optimization   on  microprocessors  not  manufactured  by
              Intel.  Microprocessor-dependent  optimizations  in  this
              product  are intended for use with Intel microprocessors.
              Certain optimizations not specific to  Intel  microarchi-
              tecture  are  reserved  for Intel microprocessors. Please
              refer to the applicable product User and Reference Guides
              for  more  information regarding the specific instruction
              sets covered by this notice.

              Notice revision #20110804

              = = = = = = = = = =

              Alternate Options:

              Linux and OS X: -fopenmp

       -qopenmp-lib=type

              Lets you specify an OpenMP* run-time
                     library to use for linking. Option -qopenmp-lib is
                     the replacement option for -openmp-lib,  which  is
                     deprecated.

              Arguments:


              -qopenmp-lib=compat
                                The  compiler  uses  the  compatibility
                                OpenMP* run-time library (libiomp).

              Description:

              This  option lets you specify an OpenMP* run-time library
              to use for linking.

              The compatibility OpenMP run-time libraries are  compati-
              ble with object files created using the Microsoft* OpenMP
              run-time library  (vcomp)  or  the  GNU  OpenMP  run-time
              library (libgomp).

              To use the compatibility OpenMP run-time library, compile
              and link your application using the  compat  setting  for
              option  [q  or Q]openmp-lib. To use this option, you must
              also specify one of the following compiler options:

              · Linux* systems: -qopenmp or -qopenmp-stubs

              · Windows* systems: /Qopenmp or /Qopenmp-stubs

              On Windows* systems, the compatibility  OpenMP*  run-time
              library  lets  you  combine OpenMP* object files compiled
              with the Microsoft* C/C++ compiler  with  OpenMP*  object
              files  compiled  with  the  Intel(R)  C, Intel(R) C++, or
              Intel(R) Fortran compilers. The linking phase results  in
              a single, coherent copy of the run-time library.

              On   Linux*  systems,  the  compatibility  Intel  OpenMP*
              run-time library lets you combine  OpenMP*  object  files
              compiled  with  the  GNU*  gcc or gfortran compilers with
              similar OpenMP* object files compiled with  the  Intel(R)
              C, Intel(R) C++, or Intel(R) Fortran compilers. The link-
              ing phase results in  a  single,  coherent  copy  of  the
              run-time library.

              NOTE:  The  compatibility  OpenMP run-time library is not
              compatible with object files created  using  versions  of
              the Intel compilers earlier than 10.0.

              NOTE:  On  Windows*  systems, this option is processed by
              the compiler,  which  adds  directives  to  the  compiled
              object  file  that are processed by the linker. On Linux*
              and OS X*  systems,  this  option  is  processed  by  the
              icc/icpc  command  that initiates linking, adding library
              names explicitly to the link command.

              Alternate Options:

                                static         Tells  the  compiler  to
                                               link  to  static  OpenMP
                                               run-time libraries. Note
                                               that    static    OpenMP
                                               libraries            are
                                               deprecated.

                                dynamic        Tells  the  compiler  to
                                               link  to  dynamic OpenMP
                                               run-time libraries.

              Default:

              -qopenmp-link=dynamic
                                The compiler links to  dynamic  OpenMP*
                                run-time  libraries. However, if Linux*
                                option -static is specified,  the  com-
                                piler  links  to static OpenMP run-time
                                libraries.

              Description:

              This option controls whether the compiler links to static
              or dynamic OpenMP* run-time libraries.

              To  link  to the static OpenMP run-time 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.

              NOTE: Compiler options  -static-intel  and  -shared-intel
              (Linux*  and  OS  X*)  have  no  effect  on  which OpenMP
              run-time library is linked.

              NOTE: On Linux* systems, -qopenmp-link=dynamic cannot  be
              used  in  conjunction  with option -static. If you try to
              specify both options together,  an  error  will  be  dis-
              played.

              NOTE:  On  Linux  systems,  the  OpenMP  runtime  library
              depends on using libpthread and libc  (libgcc  when  com-
              piled  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 runtime may be used.

              Alternate Options:

              None

                     Intel(R)  Graphics  Technology,  or on Intel(R) 64
                     architecture targeting Intel(R) Graphics  Technol-
                     ogy

              Arguments:

              device            Specifies the default device for target
                                pragmas. Possible values are:

                                mic            Specifies   the   target
                                               device  is  Intel(R) MIC
                                               Architecture;  this   is
                                               the  default. This value
                                               is  available  for  Win-
                                               dows* and Linux* systems
                                               on Intel(R) 64 architec-
                                               ture

                                gfx            Specifies   the   target
                                               device    is    Intel(R)
                                               Graphics     Technology.
                                               This value is  available
                                               for  Windows* and Linux*
                                               systems on  Intel(R)  64
                                               architecture,   and   on
                                               Windows*   systems    on
                                               IA-32 architecture.

                                host           Causes  the  target code
                                               to run on the host  sys-
                                               tem,  while  still doing
                                               the    outlining     for
                                               offload.  This  lets you
                                               test #pragma omp  target
                                               when no target device is
                                               available. This value is
                                               available  for  Windows*
                                               and  Linux*  systems  on
                                               IA-32  and  Intel(R)  64
                                               architecture.

              Default:

              -qno-openmp-offload
                                OpenMP* offloading compilation is  dis-
                                abled.    However,   if  option  [q  or
                                Q]openmp is specified, the  default  is
                                ON and OpenMP offloading compilation is
                                enabled.

              Description:

              Alternate Options:

              None

       -qopenmp-simd

       -qno-openmp-simd

              Enables or disables OpenMP* SIMD
                     compilation. Option -qopenmp-simd is the  replace-
                     ment option for -openmp-simd, which is deprecated.

              Arguments:

              None

              Default:

              -qno-openmp-simd  OpenMP* SIMD compilation  is  disabled.
                                However,  if  option  [q or Q]openmp is
                                specified, the default is ON and OpenMP
                                SIMD compilation is enabled.

              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.

              If you specify  this  option  with  the  [q  or  Q]openmp
              option, it can impact other OpenMP features.

              Alternate Options:

              None

       -qopenmp-stubs

              Enables compilation of OpenMP* programs
                     in  sequential  mode. Option -qopenmp-stubs is the
                     replacement option  for  -openmp-stubs,  which  is
                     deprecated.

              Arguments:

              None

              Default:

       -qopenmp-task=model

              Lets  you  choose  an  OpenMP*  tasking   model.   Option
              -qopenmp-task is the replacement option for -openmp-task,
              which is deprecated.

              Arguments:

              model             Is an OpenMP  tasking  model.  Possible
                                values are:

                                intel          Tells  the  compiler  to
                                               accept Intel taskqueuing
                                               pragmas         (#pragma
                                               intel_omp_taskq      and
                                               #pragma intel_omp_task).
                                               When this value is spec-
                                               ified,  OpenMP  API  3.0
                                               tasking   pragmas    are
                                               ignored;   if  they  are
                                               specified, warnings  are
                                               issued.

                                omp            Tells  the  compiler  to
                                               accept OpenMP*  API  3.0
                                               tasking pragmas (#pragma
                                               omp_task).   When   this
                                               value    is   specified,
                                               Intel taskqueuing  prag-
                                               mas are ignored; if they
                                               are specified,  warnings
                                               are issued.

              Default:

              -qopenmp-task=omp The compiler accepts OpenMP 3.0 tasking
                                pragmas.

              Description:

              The option lets you choose an OpenMP tasking model.

              To use this option, you must also specify  option  [q  or
              Q]openmp.

              Alternate Options:

              None

       -qopenmp-threadprivate=type (L*X only)

              Lets you specify an OpenMP* threadprivate
                                               Intel(R)  compiler. This
                                               setting does not provide
                                               compatibility  with  the
                                               implementation  used  by
                                               other compilers.

                                compat         Tells  the  compiler  to
                                               use  the   compatibility
                                               OpenMP*    threadprivate
                                               implementation based  on
                                               applying             the
                                               __declspec(thread)
                                               attribute     to    each
                                               threadprivate  variable.
                                               The  limitations  of the
                                               attribute  on  a   given
                                               platform  also  apply to
                                               the threadprivate imple-
                                               mentation.  This setting
                                               provides   compatibility
                                               with  the implementation
                                               provided     by      the
                                               Microsoft* and GNU* com-
                                               pilers.

              Default:

              -qopenmp-threadprivate=legacy
                                The compiler uses  the  legacy  OpenMP*
                                threadprivate  implementation  used  in
                                the previous releases of the Intel com-
                                piler.

              Description:

              This  option  lets  you  specify an OpenMP* threadprivate
              implementation.

              The threadprivate implementation  of  the  legacy  OpenMP
              run-time  library may not be compatible with object files
              created using  OpenMP  run-time  libraries  supported  in
              other compilers.

              To use this option, you must also specify one of the fol-
              lowing compiler options:

              · Linux* systems: -qopenmp or -qopenmp-stubs

              · Windows* systems: /Qopenmp or /Qopenmp-stubs

              The value specified for this option is independent of the
              value used for the [q or Q]openmp-lib option.
              -opt-args-in-regs, which is deprecated.

              Architecture Restrictions: Only available on IA-32 archi-
              tecture

              Arguments:

              keyword           Specifies   whether   the  optimization
                                should be performed and under what con-
                                ditions.  Possible values are:

                                none           The  optimization is not
                                               performed. No parameters
                                               are passed in registers.
                                               They  are  put  on   the
                                               stack.

                                seen           Causes  parameters to be
                                               passed in registers when
                                               they  are passed to rou-
                                               tines  whose  definition
                                               can  be seen in the same
                                               compilation unit.

                                all            Causes parameters to  be
                                               passed   in   registers,
                                               whether they are  passed
                                               to  routines whose defi-
                                               nition can  be  seen  in
                                               the   same   compilation
                                               unit, or not. This value
                                               is   only  available  on
                                               Linux* systems.

              Default:

              -qopt-args-in-regs=seen
                                Parameters are passed in registers when
                                they are passed to routines whose defi-
                                nition is seen in the same  compilation
                                unit.

              Description:

              This  option  determines  whether  calls  to routines are
              optimized by passing parameters in registers  instead  of
              on  the  stack. It also indicates the conditions when the
              optimization will be performed.

              This  option  can  improve  performance  for  Application
              Binary  Interfaces  (ABIs)  that require parameters to be
              passed in memory  and  compiled  without  interprocedural

       -qno-opt-assume-safe-padding (L*X only)

              Determines whether the compiler assumes
                     that variables and  dynamically  allocated  memory
                     are  padded  past  the  end  of the object. Option
                     -qopt-assume-safe-padding   is   the   replacement
                     option for -opt-assume-safe-padding, which is dep-
                     recated.

              Architecture Restrictions: Only available on Intel(R)  64
              architecture targeting the
                     Intel(R) Xeon  Phi(TM)  coprocessor  x100  product
                     family (formerly code name Knights Corner)

              Arguments:

              None

              Default:

              -qno-opt-assume-safe-padding
                                The compiler will not assume that vari-
                                ables and dynamically allocated  memory
                                are  padded past the end of the object.
                                It will adhere to the  sizes  specified
                                in your program.

              Description:

              This  option determines whether the compiler assumes that
              variables and dynamically  allocated  memory  are  padded
              past the end of the object.

              When  you specify option [q or Q]opt-assume-safe-padding,
              the compiler assumes that variables and dynamically allo-
              cated  memory are padded. This means that code can access
              up to 64 bytes beyond what is specified in your  program.

              The  compiler  does  not  add  any padding for static and
              automatic objects  when  this  option  is  used,  but  it
              assumes  that  code  can access up to 64 bytes beyond the
              end of the object, wherever the  object  appears  in  the
              program.  To  satisfy  this assumption, you must increase
              the size of static and automatic objects in your  program
              when you use this option.

              This option may improve performance of memory operations.

              Alternate Options:

              None

              OFF               The  compiler  uses  default heuristics
                                for loop blocking.

              Description:

              This option lets you specify a loop blocking factor.

              Alternate Options:

              None

       -qopt-calloc (L*X only)

       -qno-opt-calloc (L*X only)

              Tells   the   compiler   to   substitute   a   call    to
              _intel_fast_calloc()  for  a  call  to  calloc().  Option
              -qopt-calloc is the replacement option  for  -opt-calloc,
              which is deprecated.

              Arguments:

              None

              Default:

              -qno-opt-calloc   The compiler does not substitute a call
                                to  _intel_fast_calloc()  for a call to
                                calloc().

              Description:

              This option tells  the  compiler  to  substitute  a  call
              to_intel_fast_calloc() for a call to calloc().

              This  option may increase the performance of long-running
              programs that use calloc() frequently. It is  recommended
              for   these   programs   over   combinations  of  options
              -inline-calloc and  -qopt-malloc-options=3  because  this
              option causes less memory fragmentation.

              NOTE: Many routines in the LIBIRC library are more highly
              optimized for Intel(R) microprocessors than for non-Intel
              microprocessors.

              Alternate Options:

              None

       -qopt-class-analysis

                                C++  class hierarchy information is not
                                used to analyze and resolve C++ virtual
                                function calls at compile time.

              Description:

              This option determines whether C++ class hierarchy infor-
              mation is used to analyze and resolve C++  virtual  func-
              tion  calls  at  compile time. The option is turned on by
              default with the -ipo compiler option, enabling  improved
              C++ optimization. If a C++ application contains non-stan-
              dard C++ constructs, such as pointer down-casting, it may
              result in different behaviors.

              Alternate Options:

              None

       -qopt-dynamic-align

       -qno-opt-dynamic-align

              Enables or disables dynamic data alignment optimizations.
              Option -qopt-dynamic-align is the replacement option  for
              -opt-dynamic-align, which is deprecated.

              Arguments:

              None

              Default:

              -qopt-dynamic-align
                                The  compiler may generate code dynami-
                                cally dependent on alignment. It may do
                                optimizations  based  on  data location
                                for the best performance. The result of
                                execution on some algorithms may depend
                                on data layout.

              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
              None

       -qopt-gather-scatter-unroll=n (L*X only)

       -qno-opt-gather-scatter-unroll (L*X only)

              Lets you specify an alternative loop
                     unroll sequence  for  gather  and  scatter  loops.
                     Option -qopt-gather-scatter-unroll is the replace-
                     ment option for -opt-gather-scatter-unroll,  which
                     is deprecated.

              Architecture  Restrictions: Only available on Intel(R) 64
              architecture targeting the
                     Intel(R)  Xeon  Phi(TM)  coprocessor  x100 product
                     family (formerly code name Knights Corner)

              Arguments:

              n                 Is the unroll factor for the gather and
                                scatter  loops.  It  must be an integer
                                between 0 and 8. If you specify value 0
                                for n, it is the same as specifying the
                                negative form of the option.

              Default:

              -qno-opt-gather-scatter-unroll or
                                /Qopt-gather-scatter-unroll  The   com-
                                piler   uses  default  heuristics  when
                                unrolling gather and scatter loops.

              Description:

              This option lets you specify an alternative  loop  unroll
              sequence for gather and scatter loops.

              This  option  may  improve  performance of gather/scatter
              operations.

              The value of n that  provides  the  best  performance  is
              data-dependent.

              In cases where the gather/scatter operation accesses data
              in a small number of cache-lines (such as 1  or  2),  the
              default  sequence (using a small value for n) works best.
              In cases where each individual data item falls in a  dif-
              ferent  cache-line, it may be better to use a large value
              for n.

              Alternate Options:

                                tables.  Possible values are:

                                never          Tells  the  compiler  to
                                               never   generate    jump
                                               tables.    All    switch
                                               statements  are   imple-
                                               mented   as   chains  of
                                               if-then-elses.  This  is
                                               the  same  as specifying
                                               -qno-opt-jump-tables
                                               (Linux*  and  OS  X*) or
                                               /Qopt-jump-tables- (Win-
                                               dows*).

                                default        The     compiler    uses
                                               default  heuristics   to
                                               determine when to gener-
                                               ate jump tables.

                                large          Tells  the  compiler  to
                                               generate  jump tables up
                                               to a certain pre-defined
                                               size (64K entries).

                                n              Must   be   an  integer.
                                               Tells  the  compiler  to
                                               generate  jump tables up
                                               to n entries in size.

              Default:

              -qopt-jump-tables=default
                                The compiler uses default heuristics to
                                determine  when to generate jump tables
                                for switch statements.

              Description:

              This option enables or disables generation of jump tables
              for switch statements. When the option is enabled, it may
              improve performance for programs with large switch state-
              ments.

              Alternate Options:

              None

       -qopt-malloc-options=n

              Lets  you  specify  an  alternate algorithm for malloc().
              Option -qopt-malloc-options is the replacement option for
              -opt-malloc-options, which is deprecated.
                                               M_MMAP_MAX=2         and
                                               M_TRIM_THRESH-
                                               OLD=0x10000000.

                                2              Causes   the   following
                                               adjustments  to the mal-
                                               loc()         algorithm:
                                               M_MMAP_MAX=2         and
                                               M_TRIM_THRESH-
                                               OLD=0x40000000.

                                3              Causes   the   following
                                               adjustments to the  mal-
                                               loc()         algorithm:
                                               M_MMAP_MAX=0         and
                                               M_TRIM_THRESHOLD=-1.

                                4              Causes   the   following
                                               adjustments to the  mal-
                                               loc()         algorithm:
                                               M_MMAP_MAX=0,
                                               M_TRIM_THRESHOLD=-1,
                                               M_TOP_PAD=4096.

              Default:

              -qopt-malloc-options=0
                                The compiler uses the default algorithm
                                when  malloc()  is  called.  No call is
                                made to mallopt().

              Description:

              This option lets you specify an alternate  algorithm  for
              malloc().

              If  you  specify a non-zero value for n, it causes alter-
              nate configuration parameters to be set for how  malloc()
              allocates  and  frees  memory.  It  tells the compiler to
              insert calls to mallopt() to adjust these  parameters  to
              malloc()  for dynamic memory allocation. This may improve
              speed.

              Alternate Options:

              None

       -qopt-matmul (L*X only)

       -qno-opt-matmul (L*X only)

              Enables or disables a compiler-generated
              None

              Default:

              -qno-opt-matmul   The matmul  library  call  optimization
                                does  not  occur  unless this option is
                                enabled  or  certain   other   compiler
                                options are specified (see below).

              Description:

              This  option  enables  or  disables  a compiler-generated
              Matrix Multiply (MATMUL) library call.

              The [q or Q]opt-matmul option tells the compiler to iden-
              tify  matrix  multiplication  loop  nests  (if  any)  and
              replace them with a matmul library call for improved per-
              formance.  The  resulting  executable  may get additional
              performance gain  on  Intel(R)  microprocessors  than  on
              non-Intel microprocessors.

              NOTE:  This option is dependent upon the OpenMP* library.
              If your product does not support OpenMP, this option will
              have no effect.

              This  option  is  enabled  by  default  if options O3 and
              [Q]parallel are specified. To disable this  optimization,
              specify -qno-opt-matmul or /Qopt-matmul-.

              This  option  has no effect unless option O2 or higher is
              set.

              NOTE: Many routines in the MATMUL library are more highly
              optimized for Intel(R) microprocessors than for non-Intel
              microprocessors.

              Alternate Options:

              None

       -qopt-mem-layout-trans[=n]

       -qno-opt-mem-layout-trans

              Controls the level of memory layout
                     transformations performed by the compiler.  Option
                     -qopt-mem-layout-trans  is  the replacement option
                     for -opt-mem-layout-trans, which is deprecated.

              Architecture Restrictions: Not available on  Intel(R)  64
              architecture targeting the
                     Intel(R) Xeon  Phi(TM)  coprocessor  x100  product
                                               out-trans (Linux* and OS
                                               X*)  or   /Qopt-mem-lay-
                                               out-trans- (Windows*).

                                1              Enables   basic   memory
                                               layout  transformations.

                                2              Enables more memory lay-
                                               out     transformations.
                                               This   is  the  same  as
                                               specifying     [q     or
                                               Q]opt-mem-layout-trans
                                               with no argument.

                                3              Enables aggressive  mem-
                                               ory  layout  transforma-
                                               tions. You  should  only
                                               use this setting if your
                                               system has 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 transfor-
              mations  performed  by  the  compiler.  This  option  can
              improve cache reuse and cache locality.


              Optimization Notice


              = = = = = = = = = =

              Intel's  compilers  may  or  may not optimize to the same
              degree for non-Intel  microprocessors  for  optimizations
              that are not unique to Intel microprocessors. These opti-
              mizations include SSE2, SSE3, and SSSE3 instruction  sets
              and  other  optimizations.  Intel  does not guarantee the
              availability,  functionality,  or  effectiveness  of  any
              optimization   on  microprocessors  not  manufactured  by
              Intel.  Microprocessor-dependent  optimizations  in  this
              product  are intended for use with Intel microprocessors.
              Certain optimizations not specific to  Intel  microarchi-
              tecture  are  reserved  for Intel microprocessors. Please
              refer to the applicable product User and Reference Guides

              Tells the compiler to use aggressive
                     multi-versioning to check for pointer aliasing and
                     scalar   replacement.   Option    -qopt-multi-ver-
                     sion-aggressive  is  the  replacement  option  for
                     -opt-multi-version-aggressive,  which  is   depre-
                     cated.

              Arguments:

              None

              Default:

              -qno-opt-multi-version-aggressive
                                The  compiler  uses  default heuristics
                                when checking for pointer aliasing  and
                                scalar replacement.

              Description:

              This   option   tells  the  compiler  to  use  aggressive
              multi-versioning to check for pointer aliasing and scalar
              replacement. This option may improve performance.

              The  performance can be affected by certain options, such
              as /arch or /Qx (Windows*) or -m or  -x  (Linux*  and  OS
              X*).

              Alternate Options:

              None

       -qopt-prefetch[=n]

       -qno-opt-prefetch

              Enables or disables prefetch insertion
                     optimization.   Option   -qopt-prefetch   is   the
                     replacement option  for  -opt-prefetch,  which  is
                     deprecated.

              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

              -qno-opt-prefetch Prefetch insertion optimization is dis-
                                abled.

              Description:

              This  option enables or disables prefetch insertion opti-
              mization. The goal of  prefetching  is  to  reduce  cache
              misses  by  providing  hints  to the processor about when
              data should be loaded into the cache.

              On Intel(R) 64 architecture targeting the  Intel(R)  Xeon
              Phi(TM)  coprocessor  x100  product family (formerly code
              name Knights Corner), option -qopt-prefetch=3 (Linux* and
              OS  X*)  and  /Qopt-prefetch:3  (Windows*) are enabled by
              default if  option  O2  or  higher  is  set.  To  disable
              prefetching  at these optimization levels, specify option
              -qno-opt-prefetch or /Qopt-prefetch-.

              This option enables prefetching when higher  optimization
              levels are specified.

              Alternate Options:

              None

       -qopt-prefetch-distance=n1[,
              n2] (L*X only)

              Specifies the prefetch distance to be
                     used   for  compiler-generated  prefetches  inside
                     loops.  Option  -qopt-prefetch-distance   is   the
                     replacement   option  for  -opt-prefetch-distance,
                     which is deprecated.

              Architecture Restrictions:  Not available on IA-32 archi-
              tecture targeting Intel(R)
                     Graphics Technology, or on Intel(R)  64  architec-
                     ture targeting Intel(R) Graphics Technology

              Arguments:

              n1,               n2 Is the prefetch distance in terms of
                                the  number  of   (possibly-vectorized)
                                iterations.    Possible    values   are
                                non-negative numbers >=0.

                                n2 is optional.

                                n1 = 0 turns off  all  compiler  issued
                                prefetches  from  memory to L2.  n2 = 0
                                turns   off   all    compiler    issued

              the  loop  is vectorized by the compiler, the unit is the
              number of vectorized iterations.

              The value  of  n1  will  be  used  as  the  distance  for
              prefetches from memory to L2 (for example, the vprefetch1
              instruction). If n2 is specified, it will be used as  the
              distance  for  prefetches from L2 to L1 (for example, the
              vprefetch0 instruction).

              This  option  is  ignored  if   option   -qopt-prefetch=0
              (Linux*)  or /Qopt-prefetch:0 (Windows*) is specified. On
              Intel(R)   MIC   Architecture,    -qopt-prefetch=3    and
              /Qopt-prefetch:3  is  the default at option levels O2 and
              above.

              Alternate Options:

              None

       -qopt-prefetch-issue-excl-hint (L*X only)

              Supports the prefetchW instruction in
                     Intel(R) microarchitecture code name Broadwell and
                     later.

              Architecture  Restrictions:  Not available on Intel(R) 64
              architecture targeting the
                     Intel(R)  Xeon  Phi(TM)  coprocessor  x100 product
                     family (formerly code  name  Knights  Corner),  on
                     IA-32  architecture  targeting  Intel(R)  Graphics
                     Technology, or on Intel(R) 64 architecture target-
                     ing Intel(R) Graphics Technology

              Arguments:

              None

              Default:

              OFF               The   compiler  does  not  support  the
                                PREFETCHW instruction for this microar-
                                chitecture.

              Description:

              This   option   supports  the  PREFETCHW  instruction  in
              Intel(R) microarchitecture code name Broadwell and later.

              When  you  specify  this  option,  you  must also specify
              option [q or Q]opt-prefetch.

              The prefetch instruction is merely a hint  and  does  not
              -opt-ra-region-strategy, which is deprecated.

              Arguments:

              keyword           Is the method  used  for  partitioning.
                                Possible values are:

                                routine        Creates  a single region
                                               for each routine.

                                block          Partitions each  routine
                                               into   one   region  per
                                               basic block.

                                trace          Partitions each  routine
                                               into   one   region  per
                                               trace.

                                loop           Partitions each  routine
                                               into   one   region  per
                                               loop.

                                default        The compiler  determines
                                               which method is used for
                                               partitioning.

              Default:

              -qopt-ra-region-strategy=default
                                The compiler determines which method is
                                used for partitioning. This is also the
                                default if keyword is not specified.

              Description:

              This option selects the method that the register  alloca-
              tor uses to partition each routine into regions.

              When  setting default is in effect, the compiler attempts
              to optimize the tradeoff between compile-time performance
              and generated code performance.

              This  option  is  only  relevant  when  optimizations are
              enabled (option O1 or higher).

              Alternate Options:

              None

       -qopt-report[=n]

              Tells the compiler to generate an
                                produces the greatest level of  detail.
                                If you do not specify n, the default is
                                level 2, which produces a medium  level
                                of detail.

              Default:

              OFF               No optimization report is generated.

              Description:

              This  option  tells the compiler to generate a collection
              of optimization report files, one per object; this is the
              same     output     produced     by    option    [q    or
              Q]opt-report-per-object.

              If you prefer another form of  output,  you  can  specify
              option [q or Q]opt-report-file.

              If  you specify a level (n) higher than 5, a warning will
              be displayed and you will get a level 5 report.

              When optimization reporting is enabled,  the  default  is
              -qopt-report-phase=all    (Linux*    and    OS   X*)   or
              /Qopt-report-phase:all (Windows*).

              For a description of the information that  each  n  level
              provides,  see  the  Example  section  in  option  [q  or
              Q]opt-report-phase.

              Alternate Options:

              None

       -qopt-report-annotate[=keyword]

              Enables the annotated source listing
                     feature and specifies its format.

              Arguments:

              keyword           Specifies the format for the  annotated
                                source  listing. You can specify one of
                                the following:

                                text           Indicates that the list-
                                               ing  should  be  in text
                                               format.  This   is   the
                                               default  if  you  do not
                                               specify keyword.

                                html           Indicates that the list-

              By  default,  one  annotated  source  file  is output per
              object. The annotated file is written to the same  direc-
              tory  where the object files are generated. If the object
              file is a temporary file and an executable is  generated,
              annotated  files  are  placed  in the directory where the
              executable is placed. You cannot generate annotated files
              to a directory of your choosing.

              However,  you  can  output  annotated listings to stdout,
              stderr, or to a file if you also  specify  option  [q  or
              Q]opt-report-file.

              By  default,  this  option sets option [q or Q]opt-report
              with default level 2.

              The  following  shows  the  file  extension  and  listing
              details for the two possible keywords.

              Format             Listing Details

              text              The  annotated  source  listing  has an
                                .annot extension. It includes line num-
                                bers  and  compiler  diagnostics placed
                                after correspondent  lines.  IPO  foot-
                                notes  are inserted at the end of anno-
                                tated file.

              html              The annotated  source  listing  has  an
                                .annot.html extension. It includes line
                                numbers and compiler diagnostics placed
                                after  correspondent lines (as the text
                                format does). It also  provides  hyper-
                                links  in  compiler  messages and quick
                                navigation with the routine  list.  IPO
                                footnotes are displayed as tooltips.

              Alternate Options:

              None

       -qopt-report-annotate-position=keyword

              Enables the annotated source listing
                     feature  and specifies the site where optimization
                     messages appear in the annotated source in inlined
                     cases of loop optimizations.

              Arguments:

              keyword           Specifies  the  site where optimization
                                messages  appear   in   the   annotated
                                source. You can specify one of the fol-

              Default:

              OFF               No  annotated  source listing is gener-
                                ated

              Description:

              This option enables the annotated source listing  feature
              and specifies the site where optimization messages appear
              in the annotated source in inlined cases  of  loop  opti-
              mizations.

              This option enables option [q or Q]opt-report-annotate if
              it is not explicitly specified.

              If annotated source listing is enabled and this option is
              not  passed to compiler, loop optimizations are placed in
              caller position by default.

              Alternate Options:

              None

       -qopt-report-embed

       -qno-opt-report-embed

              Determines whether special loop
                     information annotations will be  embedded  in  the
                     object  file  and/or  the assembly file when it is
                     generated.  Option   -qopt-report-embed   is   the
                     replacement option for -opt-report-embed, which is
                     deprecated.

              Arguments:

              None

              Default:

              OFF               When an assembly file is  being  gener-
                                ated,  special loop information annota-
                                tions  will  not  be  embedded  in  the
                                assembly file.

                                However,  if  option  -g (Linux* and OS
                                X*) or  /Zi  (Windows*)  is  specified,
                                special  loop  information  annotations
                                will be embedded in the  assembly  file
                                unless   option   -qno-opt-report-embed
                                (Linux and OS X) or /Qopt-report-embed-

              If you use this option, you do not have to specify option
              [q or Q]opt-report.

              Alternate Options:

              None

       -qopt-report-file=keyword

              Specifies that the output for the
                     optimization report goes to  a  file,  stderr,  or
                     stdout.  Option  -qopt-report-file is the replace-
                     ment option for -opt-report-file, which is  depre-
                     cated.

              Arguments:

              keyword           Specifies  the  output  for the report.
                                You can specify one of the following:

                                filename       Specifies  the  name  of
                                               the  file where the out-
                                               put should go.

                                stderr         Indicates that the  out-
                                               put should go to stderr.

                                stdout         Indicates that the  out-
                                               put should go to stdout.

              Default:

              OFF               No optimization report is generated.

              Description:

              This option specifies that the output for  the  optimiza-
              tion 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.

              When optimization reporting is enabled,  the  default  is
              -qopt-report-phase=all    (Linux*    and    OS   X*)   or
              /Qopt-report-phase:all (Windows*).

              Alternate Options:

              None

       -qopt-report-filter=string

                                routine, range [, range]...

                                If  you  specify  more  than one of the
                                above forms in a  string,  a  semicolon
                                must  appear  between each form. If you
                                specify  more  than  one  range  in   a
                                string,  a  comma  must  appear between
                                each range. Optional blanks can  follow
                                each  parameter  in the forms above and
                                they can also follow  each  form  in  a
                                string.

                                filename       Specifies  the name of a
                                               file to be found. It can
                                               include a path.

                                               If  you do not specify a
                                               path, the compiler looks
                                               for  the filename in the
                                               current  working  direc-
                                               tory.

                                routine        Specifies  the name of a
                                               routine to be found. You
                                               can include an identify-
                                               ing parameter.

                                               The name, including  any
                                               parameter,    must    be
                                               enclosed    in    single
                                               quotes.

                                               The  compiler  tries  to
                                               uniquely  identify   the
                                               routine that corresponds
                                               to the specified routine
                                               name.

                                               It  may  select multiple
                                               routines   to   analyze,
                                               especially  if more than
                                               one  routine   has   the
                                               specified  routine name,
                                               so the routine cannot be
                                               uniquely identified.

                                range          Specifies   a  range  of
                                               line numbers to be found
                                               in  the  file or routine
                                               specified.   The   range
                                               must   be  specified  in
                                               integers in the form:

              This  option  tells  the  compiler  to find the indicated
              parts of  your  application,  and  generate  optimization
              reports for those parts of your application. Optimization
              reports will only be generated for the routines that con-
              tain the specified string.

              On    Linux*   and   OS   X*,   if   you   specify   both
              -qopt-report-routine=string1    and     -qopt-report-fil-
              ter=string2,   it   is   treated   as   -qopt-report-fil-
              ter=string1;string2. On Windows*,  if  you  specify  both
              /Qopt-report-routine:string1     and    /Qopt-report-fil-
              ter:string2,   it    is    treated    as/Qopt-report-fil-
              ter:string1;string2.

              If you use this option, you do not have to specify option
              [q or Q]opt-report.

              When optimization reporting is enabled,  the  default  is
              -qopt-report-phase=all    (Linux*    and    OS   X*)   or
              /Qopt-report-phase:all (Windows*).

              Alternate Options:

              None

       -qopt-report-format=keyword

              Specifies the format for an optimization
                     report. Option -qopt-report-format is the replace-
                     ment  option for -opt-report-format, which is dep-
                     recated.

              Arguments:

              keyword           Specifies the format  for  the  report.
                                You can specify one of the following:

                                text           Indicates    that    the
                                               report should be in text
                                               format.

                                vs             Indicates    that    the
                                               report  should   be   in
                                               Visual   Studio*   (IDE)
                                               format. The Visual  Stu-
                                               dio  IDE uses the infor-
                                               mation to visualize  the
                                               optimization  report  in
                                               the context of your pro-
                                               gram source code.

              Default:
              it will affect where the output goes:

              · If filename is specified, output goes to the  specified
                file.

              · If stdout is specified, output goes to stdout.

              · If stderr is specified, output goes to stderr.

              If you use this option, you do not have to specify option
              [q or Q]opt-report.

              When optimization reporting is enabled,  the  default  is
              -qopt-report-phase=all    (Linux*    and    OS   X*)   or
              /Qopt-report-phase:all (Windows*).

              Alternate Options:

              None

       -qopt-report-help

              Displays the optimizer phases available for report gener-
              ation and a short description of what is reported at each
              level. Option -qopt-report-help is the replacement option
              for -opt-report-help, which is deprecated.

              Arguments:

              None

              Default:

              OFF               No optimization report is generated.

              Description:

              This option displays the optimizer phases  available  for
              report  generation  using [q or Q]opt-report-phase, and a
              short description of what is reported at each level.   No
              compilation is performed.

              To  indicate  where output should go, you can specify one
              of the following options:

              · [q or Q]opt-report-file

              · [q or Q]opt-report-per-object

              If you use this option, you do not have to specify option
              [q or Q]opt-report.

                                mangled        Indicates that the opti-
                                               mization  report  should
                                               contain mangled names.

                                unmangled      Indicates that the opti-
                                               mization  report  should
                                               contain unmangled names.

              Default:

              OFF               No optimization report is generated.

              Description:

              This  option specifies whether mangled or unmangled names
              should appear in the optimization report. If you use this
              option, you must specify either mangled or unmangled.

              If this option is not specified, unmangled names are used
              by default.

              If you specify mangled, encoding (also known  as  decora-
              tion)  is added to names in the optimization report. This
              is appropriate when you want to  match  annotations  with
              the assembly listing.

              If  you specify unmangled, no encoding (or decoration) is
              added to names in the optimization report. This is appro-
              priate when you want to match annotations with the source
              listing.

              If you use this option, you do not have to specify option
              [q or Q]opt-report.

              When  optimization  reporting  is enabled, the default is
              -qopt-report-phase=all   (Linux*   and    OS    X*)    or
              /Qopt-report-phase:all (Windows*).

              Alternate Options:

              None

       -qopt-report-per-object

              Tells the compiler that optimization
                     report  information should be generated in a sepa-
                     rate    file    for    each    object.      Option
                     -qopt-report-per-object  is the replacement option
                     for -opt-report-per-object, which is deprecated.

              Arguments:

              object file or assembly file that  is  generated  by  the
              compiler.  For  a  multifile Interprocedural Optimization
              (IPO) compilation, one file is produced for each of the N
              true  objects  generated  in the compilation. If only one
              true object file is generated,  the  optimization  report
              file generated is called ipo_out.optrpt. If multiple true
              object files are generated  (N>1),  the  names  used  are
              ipo_out1.optprt, ipo_out2.optrpt, …ipo_outN.optrpt.

              The  .optrpt files are written to the target directory of
              the compilation process. If an object or assembly file is
              explicitly  generated,  the corresponding .optrpt file is
              written to the same directory where the  object  file  is
              generated.  If  the  object file is just a temporary file
              and an executable is generated, the corresponding .optrpt
              files are placed in the directory in which the executable
              is placed.

              If you use this option, you do not have to specify option
              [q or Q]opt-report.

              When  optimization  reporting  is enabled, the default is
              -qopt-report-phase=all   (Linux*   and    OS    X*)    or
              /Qopt-report-phase:all (Windows*).

              Alternate Options:

              None

       -qopt-report-phase[=list]

              Specifies one or more optimizer phases
                     for  which  optimization  reports  are  generated.
                     Option  -qopt-report-phase  is   the   replacement
                     option for -opt-report-phase, which is deprecated.

              Arguments:

              list              (Optional) Specifies one or more phases
                                to generate reports for. If you specify
                                more than one phase, they must be sepa-
                                rated  with  commas. The values you can
                                specify are:

                                cg             The phase for code  gen-
                                               eration

                                ipo            The  phase for Interpro-
                                               cedural Optimization

                                loop           The phase for loop  nest
                                               optimization

                                openmp         The phase for OpenMP

                                par            The  phase for auto-par-
                                               allelization

                                pgo            The  phase  for  Profile
                                               Guided Optimization

                                tcollect       The phase for trace col-
                                               lection

                                vec            The phase for vectoriza-
                                               tion

                                all            All   optimizer  phases.
                                               This is the  default  if
                                               you do not specify list.

              Default:

              OFF               No optimization report is generated.

              Description:

              This option specifies one or more  optimizer  phases  for
              which optimization reports are generated.

              Note  that  phase  offload causes the compiler to print a
              report of the input or output of variables that the  host
              sends  to  the offload target and variables that the host
              receives from the target.

              For certain  phases,  you  also  need  to  specify  other
              options:

              · If  you  specify phase cg, you must also specify option
                O1, O2 (default), or O3.

              · If you specify phase ipo, you must also specify  option
                [Q]ipo.

              · If you specify phase loop, you must also specify option
                O2 (default) or O3.

              · If you specify phase  openmp,  you  must  also  specify
                option [q or Q]openmp.

              · If  you specify phase par, you must also specify option
                [Q]parallel.

              · If you specify phase pgo, you must also specify  option
              [q or Q]opt-report.

              However,  if you want to get more details for each phase,
              specify option  [q  or  Q]opt-report=n  along  with  this
              option and indicate the level of detail you want by spec-
              ifying an appropriate value for n. (See also the  Example
              section below.)

              When  optimization  reporting  is enabled, the default is
              -qopt-report-phase=all   (Linux*   and    OS    X*)    or
              /Qopt-report-phase:all (Windows*).

              Alternate Options:

              None

       -qopt-report-routine=substring

              Tells the compiler to generate an
                     optimization report for each of the routines whose
                     names  contain  the  specified  substring.  Option
                     -qopt-report-routine is the replacement option for
                     -opt-report-routine, which is deprecated.

              Arguments:

              substring         Is the text (string) to look for.

              Default:

              OFF               No optimization report is generated.

              Description:

              This option tells the compiler to generate  an  optimiza-
              tion  report for each of the routines whose names contain
              the specified substring.

              You can also specify a sequence of  substrings  separated
              by  commas. If you do this, the compiler will generate an
              optimization report for each of the routines  whose  name
              contains one or more of these substrings.

              If you use this option, you do not have to specify option
              [q or Q]opt-report.

              When optimization reporting is enabled,  the  default  is
              -qopt-report-phase=all    (Linux*    and    OS   X*)   or
              /Qopt-report-phase:all (Windows*).

              Alternate Options:


              Arguments:

              n                 Is a value denoting the cache  eviction
                                (clevict)  level  to  use for streaming
                                loads and stores. Possible values are:

                                0              Tells  the  compiler  to
                                               use  no  cache  eviction
                                               level.

                                1              Tells  the  compiler  to
                                               use    the    L1   cache
                                               eviction level.

                                2              Tells  the  compiler  to
                                               use  the  L2 cache evic-
                                               tion level.

                                3              Tells  the  compiler  to
                                               use  the L1 and L2 cache
                                               eviction level. This  is
                                               the  default  of  you do
                                               not specify n.

              Default:

              2                 The compiler uses the L2 cache eviction
                                level.

              Description:

              This  option specifies the cache eviction (clevict) level
              to be used  by  the  compiler  for  streaming  loads  and
              stores.

              Depending  on  the level used, the compiler will generate
              clevict0 and/or  clevict1  instructions  that  evict  the
              cache-line  (corresponding to the load or the store) from
              the first-level  and  second-level  caches.  These  cache
              eviction  instructions will be generated after performing
              the corresponding load/store operation.

              For more information  on  how  to  mark  loads/stores  as
              streaming,  see the description of the vector nontemporal
              pragma.

              Alternate Options:

              None

       -qopt-streaming-stores=keyword
                                               the  assumption that the
                                               application  is   memory
                                               bound.

                                never          Disables  generation  of
                                               streaming   stores   for
                                               optimization.     Normal
                                               stores are performed.

                                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 bene-
              fit from streaming stores.

              Alternate Options:

              None

       -qopt-subscript-in-range

       -qno-opt-subscript-in-range

              Determines whether the compiler assumes that there are no
              "large" integers being  used  or  being  computed  inside
              loops. Option -qopt-subscript-in-range is the replacement
              option for -opt-subscript-in-range, which is  deprecated.

              Arguments:

              None

              Default:

              -qno-opt-subscript-in-range
                                The compiler assumes  there are "large"
                                integers being used or  being  computed
                                within loops.

              Alternate Options:

              None

       -qopt-threads-per-core=n (L*X only)

              Informs the compiler about the number of hardware threads
              per  core  that  will  be  used  for an application. This
              option only applies to Intel(R) MIC Architecture.  Option
              -qopt-threads-per-core  is  the  replacement  option  for
              -opt-threads-per-core, which is deprecated.

              Architecture Restrictions: Only available on Intel(R)  64
              architecture targeting Intel(R) MIC Architecture

              Arguments:

              n                 Is the number of hardware  threads  per
                                core  that  the  compiler should assume
                                that will be used while  executing  the
                                application.  Possible values are 1, 2,
                                3, or 4.

              Default:

              4                 Four hardware threads per core are used
                                for the application.

              Description:

              This  option  informs  the  compiler  about the number of
              hardware threads per core that will be used for an appli-
              cation.  This enables the compiler to perform better code
              optimizations (such as instruction scheduling).

              You should choose a value for n that is based on how many
              threads  will be used per core while executing the appli-
              cation. For example, if the application  is  parallelized
              using  OpenMP* API, use the value of n that uses the same
              number of threads per core as the  OpenMP*  API  affinity
              setting  will  use when executing the application code on
              the Intel(R) Xeon Phi(TM) coprocessor.

              This option does not affect the  number  of  threads  per
              core that will be used at run time.

              Code  compiled  with this option can run correctly on any
              (hardware-supported) number of threads per core.

              Alternate Options:

              None
                                lation was performed.

              Default:

              OFF               The default root directory for compiler
                                installation  is  searched for the com-
                                piler.

              Description:

              This option specifies the root directory where  the  com-
              piler  installation  was  performed.  It is useful if you
              want to use a different compiler or if you  did  not  use
              the  compilervars  shell  script  to set your environment
              variables.

              Alternate Options:

              None

       -Qlocation,string,dir

              Specifies the directory for supporting
                     tools.

              Architecture Restrictions: Not available on  Intel(R)  64
              architecture targeting the
                     Intel(R) Xeon  Phi(TM)  coprocessor  x100  product
                     family  (formerly  code  name  Knights Corner), on
                     IA-32  architecture  targeting  Intel(R)  Graphics
                     Technology, or on Intel(R) 64 architecture target-
                     ing Intel(R) Graphics Technology

              Arguments:

              string            Is the name of the tool.

              dir               Is the directory (path) where the  tool
                                is located.

              Default:

              OFF               The  compiler  looks  for  tools  in  a
                                default area.

              Description:

              This option specifies the directory for supporting tools.

              string can be any of the following:

              · c - Indicates the Intel(R) C++ compiler.

                · masm - Indicates the Microsoft assembler.

              · On Linux* and OS X* systems,  the  following  are  also
                available:

                · as - Indicates the assembler.

                · gas  -  Indicates  the GNU assembler. This setting is
                  for Linux* only.

                · ld - Indicates the loader.

                · gld - Indicates the GNU loader. This setting  is  for
                  Linux* only.

                · lib - Indicates an additional library.

                · crt - Indicates the crt%.o files linked into executa-
                  bles to contain the place to start execution.

              On Windows and OS X* systems, you can also specify a tool
              command name.

              The following shows an example on OS X* systems:

              -Qlocation,ld,/usr/bin                !  This  tells  the
              driver  to  use  /usr/bin/ld  for  the   loader   -Qloca-
              tion,ld,/usr/bin/gld           ! This tells the driver to
              use /usr/bin/gld as the loader


              The following shows an example on Windows* systems:

              /Qlocation,link,”c:Program Filesools”            ! This
              tells  the driver to use c:Program Filesoolsk.exe for the
              loader /Qlocation,link,”c:Program Filesools_link.exe” !
              This tells the driver to use c:Program Filesools_link.exe
              as the loader


              Alternate Options:

              None

              Changes the default size of the long
                     double data type.

              Arguments:

              None

              will have valid data stored in it.

              Note that the Microsoft compiler  and  Microsoft-provided
              library  routines  (such  as  printf  or long double math
              functions) do  not  provide  support  for  80-bit  float-
              ing-point values. As a result, this option should only be
              used when referencing symbols within parts of your appli-
              cation  built  with  this  option or symbols in libraries
              that were built with this option.

              Alternate Options:

              None

       -Qoption,string,options

              Passes options to a specified tool.

              Architecture Restrictions: Not available on  Intel(R)  64
              architecture targeting the
                     Intel(R) Xeon  Phi(TM)  coprocessor  x100  product
                     family  (formerly  code  name  Knights Corner), on
                     IA-32  architecture  targeting  Intel(R)  Graphics
                     Technology, or on Intel(R) 64 architecture target-
                     ing Intel(R) Graphics Technology

              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 Intel compiler preprocessor.
                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 executa-
                  bles to contain the place to start execution.

              Alternate Options:

              None

       -rcd

              Enables fast float-to-integer conversions.

              Arguments:

              None

              Default:

              OFF               Floating-point   values  are  truncated
                                when a  conversion  to  an  integer  is
                                involved.

              Description:

              This option enables fast float-to-integer conversions. It
              can improve the performance of code that requires  float-
              ing-point-to-integer conversions.

              The   system  default  floating-point  rounding  mode  is
              round-to-nearest. However, the C language requires float-
              ing-point  values to be truncated when a conversion to an
              integer is involved. To do this, the compiler must change
              the  rounding  mode  to  truncation  before  each  float-
              ing-point-to-integer conversion and change it back after-
              wards.

              This  option  disables  the  change  to truncation of the
              rounding  mode  for  all   floating-point   calculations,
              including  floating  point-to-integer  conversions.  This
              option can improve performance, but  floating-point  con-
              versions to integer will not conform to C semantics.

              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 con-
              vention ensures that  as  many  values  as  possible  are
              passed or returned in registers.

              It  ensures that __regcall is the default calling conven-
              tion 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

       -restrict

       -no-restrict

              Determines whether pointer disambiguation
                     is enabled with the restrict qualifier.

              Arguments:

              None

              Default:

              -no-restrict      Pointers are  not  qualified  with  the
                                restrict keyword.

              Description:

              This  option determines whether pointer disambiguation is
              enabled with the restrict qualifier. Option -restrict and
              /Qrestrict enable the recognition of the restrict keyword
              as defined by the ANSI standard.

              By qualifying a pointer with the  restrict  keyword,  you
              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* and OS X* systems, the assembly file name has a
              .s suffix. On Windows* systems, the  assembly  file  name
              has an .asm suffix.

              Alternate Options:

              Linux and OS X: None

       -save-temps

       -no-save-temps

              Tells the compiler to save intermediate
                     files created during compilation.

              Arguments:

              None

              Default:

              Linux* and OS X* systems:
                                -no-save-temps  On  Linux and OS X sys-
                                tems, 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  [Q]save-temps  is  specified,  the  following
              occurs:

              · The  object .o file (Linux and OS X) or .obj file (Win-

              If  /Qsave-temps-  is  specified  on Windows systems, the
              following occurs:

              · The .obj file is not saved after the linker step.

              · 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

       -scalar-rep

       -no-scalar-rep

              Enables or disables the scalar  replacement  optimization
              done by the compiler as part of loop transformations.

              Arguments:

              None

              Default:

              -scalar-rep       Scalar replacement is performed  during
                                loop   transformation  at  optimization
                                levels of O2 and above.

              Description:

              This option enables or disables  the  scalar  replacement
              optimization  done by the compiler as part of loop trans-
              formations. This option takes effect only if you  specify
              an optimization level of O2 or higher.

              Alternate Options:

              None

       -shared (L*X only)

              Tells  the  compiler  to  produce a dynamic shared object
              instead of an executable.

              Arguments:

              None

              Alternate Options:

              None

       -shared-intel

              Causes  Intel-provided  libraries to be linked in dynami-
              cally.

              Arguments:

              None

              Default:

              OFF               Intel(R) libraries are linked in stati-
                                cally, with the  exception  of  Intel's
                                OpenMP*  runtime support library, which
                                is linked in dynamically.

              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 ifort (icc/icpc) 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: On OS X*  systems,  when  you  set  "Intel  Runtime
              Libraries"   to   "Dynamic",   you   must  also  set  the
              DYLD_LIBRARY_PATH environment variable within  Xcode*  or
              an error will be displayed.

              Alternate Options:

              None

       -shared-libgcc (L*X only)

              Links the GNU libgcc library dynamically.

              Arguments:

              None

              Default:

              libraries to be linked statically.

              Alternate Options:

              None

       -simd

       -no-simd

              Enables or disables compiler
                     interpretation of simd pragmas.

              Arguments:

              None

              Default:

              -simd             SIMD pragmas are enabled.

              Description:

              This  option  enables or disables compiler interpretation
              of simd pragmas.

              To  disable  interpretation  of  simd  pragmas,   specify
              -no-simd  (Linux*  and OS X*) or /Qsimd- (Windows*). Note
              that the compiler may still vectorize loops based on  its
              own  heuristics  (leading  to generation of SIMD instruc-
              tions) even when -no-simd (or /Qsimd-) is specified.

              To disable all compiler vectorization, use  the  "-no-vec
              -no-simd"  (Linux*  and  OS X*) or "/Qvec- /Qsimd-" (Win-
              dows*) compiler options. The option -no-vec (and  /Qvec-)
              disables  all auto-vectorization, including vectorization
              of array notation statements. The  option  -no-simd  (and
              /Qsimd-)  disables  vectorization of loops that have simd
              pragmas.

              NOTE: If you specify option -mia32 or option  /arch:IA32,
              simd  pragmas  are disabled by default.  When you specify
              option -mia32 or option /arch:IA32,  vector  instructions
              cannot  be  used. Therefore, you cannot explicitly enable
              SIMD pragmas by specifying option [Q]simd.

              Alternate Options:

              None

       -simd-function-pointers

                                only be placed in function declarations
                                and definitions.

              Description:

              This  option enables or disables pointers to simd-enabled
              functions.

              When option [Q]simd-function-pointers  is  specified,  it
              defines  simd-enabled (vector) function pointers by plac-
              ing vector specifications with all usual clauses in func-
              tion pointer declarations. The vector specifications must
              be indicated in an attribute  vector  declaration  or  in
              pragma omp declare simd.

              These  pointers  can enable indirect calls to appropriate
              vector versions of the  function  from  a  simd  loop  or
              another simd-enabled function.

              Alternate Options:

              None

       -sox[=keyword[,keyword]] (L*X only)

       -no-sox (L*X only)

              Tells  the  compiler  to save the compilation options and
              version number in the executable file.  It also lets  you
              choose whether to include lists of certain functions.

              Arguments:

              keyword           Is the function information to include.
                                Possible values are:

                                inline         Includes a list  of  the
                                               functions    that   were
                                               inlined in each  object.

                                profile        Includes  a  list of the
                                               functions that were com-
                                               piled with the -prof-use
                                               option and for which the
                                               .dpi  file  had  profile
                                               information,   and    an
                                               indication  for  each as
                                               to whether  the  profile
                                               information   was   USED
                                               (matched)   or   IGNORED
                                               (mismatched).

              saves the compiler options and version number used in the
              compilation of the objects that make up the executable.

              When you specify this option, the size of the  executable
              on  disk is increased slightly. Each keyword  you specify
              increases the size of the executable.  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.

              Alternate Options:

              None

       -static-intel

              Causes  Intel-provided  libraries  to be linked in stati-
              cally.

              Arguments:

              None

              Default:

              ON                Intel  libraries  are  linked in stati-
                                cally, with the  exception  of  Intel's
                                OpenMP*  runtime support library, which

              If  you  specify  option  static-intel  and  any  of  the
              Intel-provided libraries have no static version, a  diag-
              nostic will be displayed.

              Alternate Options:

              None

       -staticlib (M*X only)

              Invokes the libtool command to generate static libraries.

              Architecture  Restrictions:  Not available on Intel(R) 64
              architecture targeting Intel(R) MIC Architecture

              Arguments:

              None

              Default:

              OFF               The compiler produces an executable.

              Description:

              This  option  invokes  the  libtool  command  to generate
              static libraries. This option is processed by the command
              that  initiates  linking, adding library names explicitly
              to the link command.

              When passed this option, the compiler  uses  the  libtool
              command  to  produce  a static library instead of an exe-
              cutable when linking.

              To build dynamic libraries,  you  should  specify  option
              -dynamiclib or libtool -dynamic <objects>.

              Alternate Options:

              None

       -static-libgcc (L*X only)

              Links the GNU libgcc library statically.

              Arguments:

              None

              Default:

              dynamically.

              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 ifort (icc/icpc) 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.

              Alternate Options:

              None

       -std=val

              Tells the compiler to conform to a
                     specific language standard.

              Arguments:

              val               Specifies  the  specific language stan-
                                dard to  conform  to.  Possible  values
                                are:

                                c++14          Enables  support for the
                                               2014  ISO  C++  standard
                                               features.  The following
                                               features are available:

                                               · Tweaked  working   for
                                                 contextual conversion

                                               · Variable templates

                                               · Extended constexpr

                                               · NSDMIs for aggregates

                                               · Avoiding/fusing  allo-
                                                 cations

                                               · [deprecated]
                                                 attributes

                                               · Sized deallocation

                                               · Single-Quotation-Mark
                                                 as a digit separator

                                c++11          Enables support for many
                                               C++11 (formerly known as
                                               C++0x)   features.   The
                                               following  features  are
                                               available:

                                               · Defining  move special
                                                 member       functions
                                                 (N3053)

                                               · Explicit virtual over-
                                                 rides
                                                 (N2928,N3206,N3272)

                                               · Full implementation of
                                                 constexpr  (this  fea-
                                                 ture is only available
                                                 on Linux*  and  OS  X*
                                                 systems)

                                               · Full implementation of
                                                 initializer lists

                                               · Full implementation of
                                                 noexcept

                                               · Full implementation of
                                                 non static  data  mem-
                                                 bers  (i.e. field ini-
                                                 tializers)

                                               · Raw  string   literals
                                                 and UTF-8 literals

                                               · Delegating   construc-
                                               For a list of C++11 fea-
                                               tures that  were  previ-
                                               ously implemented by the
                                               Intel(R)  C++  Compiler,
                                               see  the  article titled
                                               C++11 Features Supported
                                               by   Intel(R)  C++  Com-
                                               piler, which is  located
                                               in          http://soft-
                                               ware.intel.com/en-us/arti-
                                               cles/c0x-features-sup-
                                               ported-by-intel-c-com-
                                               piler/

                                c89            Conforms  to the ISO/IEC
                                               9899:1990  International
                                               Standard.  This value is
                                               only available on Linux*
                                               and OS X* systems.

                                c99            Conforms  to The ISO/IEC
                                               9899:1999  International
                                               Standard.

                                gnu89          Conforms to ISO C90 plus
                                               GNU*  extensions.   This
                                               value  is only available
                                               on Linux* and OS X* sys-
                                               tems.

                                gnu99          Conforms to ISO C99 plus
                                               GNU*  extensions.   This
                                               value  is only available
                                               on Linux* and OS X* sys-
                                               tems.

                                gnu++98        Conforms to the 1998 ISO
                                               C++  standard  plus  GNU
                                               extensions.  This  value
                                               is  only  available   on
                                               Linux*  and  OS  X* sys-
                                               tems.

                                c++0x          This value is equivalent
                                               to    specifying   value
                                               c++11.

                                gnu++0x        This value is equivalent
                                               to    specifying   value
                                               c++0x.  This  value   is
                                               only available on Linux*
                                               and OS X* systems.

              language standard.

              On  Windows* systems, you can only specify values c99 and
              c++0x.

              Alternate Options:

              None

       -stdlib[=keyword] (M*X only)

       (M*X only)

              Lets you select the C++ library to be
                     used for linking.

              Architecture Restrictions: Not available on  Intel(R)  64
              architecture targeting the
                     Intel(R) Xeon  Phi(TM)  coprocessor  x100  product
                     family (formerly code name Knights Corner)

              Arguments:

              keyword           Is the function information to include.
                                Possible values are:

                                libc++         Links using  the  libc++
                                               library.

                                libstdc++      Links using the GNU lib-
                                               stdc++ library.

              Default:

              -stdlib=libc++    The compiler  links  using  the  libc++
                                library.

              Description:

              This  option  lets  you select the C++ library to be used
              for linking. This option is processed by the command that
              initiates linking, adding library names explicitly to the
              link command.

              Currently, if you do not specify this option, the  libc++
              headers and library are used.

              NOTE:  The  IDE  provides  another  possible  setting for
              option  -stdlib,  which  lets  you  choose  the  compiler
              default rather than a specific library.

              Alternate Options:
              OFF               The  compiler conforms to default stan-
                                dards.

              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 com-
              piler  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 func-
              tions as having side effects.

              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.

              Alternate Options:

              None

       -tbb

              Tells the compiler to link to the Intel(R)
                     Threading   Building   Blocks    (Intel(R)    TBB)
                     libraries.

              Arguments:

              None

              Default:
              icc/icpc command that initiates linking,  adding  library
              names explicitly to the link command.

              Alternate Options:

              None

       -tcollect[lib] (L*X only)

              Inserts instrumentation probes calling the Intel(R) Trace
              Collector API.

              Architecture  Restrictions: Not available on IA-32 archi-
              tecture targeting Intel(R)  Graphics  Technology,  or  on
              Intel(R)  64  architecture  targeting  Intel(R)  Graphics
              Technology

              Arguments:

              lib               Is  one of the Intel(R) Trace Collector
                                libraries; for example, VT, VTcs, VTmc,
                                or VTfs. If you do not specify lib, the
                                default library is VT.

              Default:

              OFF               Instrumentation probes are not inserted
                                into compiled applications.

              Description:

              This  option  inserts  instrumentation probes calling the
              Intel(R) Trace Collector API.

              This trace analyzing/collecting feature requires  instal-
              lation of another product. For more information, see Fea-
              ture Requirements.

              This option provides a flexible  and  convenient  way  of
              instrumenting  functions  of  a compiled application. For
              every function, the entry and  exit  points  are  instru-
              mented  at compile time to let the Intel(R) Trace Collec-
              tor record functions beyond the default  MPI  calls.  For
              non-MPI  applications  (for example, threaded or serial),
              you must ensure that  the  Intel(R)  Trace  Collector  is
              properly initialized (VT_initialize/VT_init).

              CAUTION:  Be  careful  with  full instrumentation because
              this feature can produce very large trace files.

              Alternate Options:

              filename          Is a configuration file that lists fil-
                                ters, one per line.  Each  filter  con-
                                sists  of  a  regular expression string
                                and a switch. Strings with  leading  or
                                trailing  white  spaces must be quoted.
                                Other strings do not have to be quoted.
                                The switch value can be ON, on, OFF, or
                                off.

              Default:

              OFF               Functions are  not  instrumented.  How-
                                ever,  if  option  -tcollect (Linux) is
                                specified, the filter  setting  is  ".*
                                ON" and all functions get instrumented.

              Description:

              This option lets you enable or disable  the  instrumenta-
              tion of specified functions.

              During  instrumentation,  the  regular expressions in the
              file are matched against the function names.  The  switch
              specifies  whether  matching  functions are to be instru-
              mented or not. Multiple filters are evaluated from top to
              bottom with increasing precedence.

              The names of the functions to match against are formatted
              as follows:

              · C++ function names are  demangled  and  the  C++  class
                hierarchy  is used. Function parameters are stripped to
                keep the function names shorter.

              · The source file name is followed by  a  colon-separated
                function  name.  Source  file  names should contain the
                full path, if available.  For example:

                /home/joe/src/foo.c:FOO_bar

              · Classes and function  names  are  separated  by  double
                colons. For example:

                /home/joe/src/foo.cpp:app::foo::bar

              You  can use option [q or Q]opt-report to get a full list
              of file and function names that the  compiler  recognizes
              from  the  compilation unit. This list can be used as the
              basis for filtering in the configuration file.

              This trace analyzing/collecting feature requires  instal-
              lation of another product. For more information, see Fea-
              Arguments:

              None

              Default:

              notraceback       No extra information  is  generated  in
                                the  object  file  to produce traceback
                                information.

              Description:

              This option tells the compiler to generate extra informa-
              tion  in the object file to provide source file traceback
              information when a severe error occurs at run time.  This
              is intended for use with C code that is to be linked into
              a Fortran program.

              When the severe error occurs, source file, routine  name,
              and  line  number  correlation  information  is displayed
              along with  call  stack  hexadecimal  addresses  (program
              counter trace).

              Note  that when a severe error occurs, advanced users can
              also locate the cause of the error using a map  file  and
              the hexadecimal addresses of the stack displayed when the
              error occurs.

              This option increases the size of the executable program,
              but has no impact on run-time execution speeds.

              It functions independently of the debug option.

              On  Windows*  systems,  traceback  sets  the /Oy- option,
              which forces the compiler to use EBP as the  stack  frame
              pointer.

              On  Windows*  systems,  the  linker  places the traceback
              information in the executable image, in a  section  named
              ".trace".  To see which sections are in an image, use the
              command:

              link -dump -summary your_app_name.exe


              To see more detailed information, use the command:

              link -dump -headers your_app_name.exe


              On Linux* systems, to display the section headers in  the
              image  (including  the  header for the .trace section, if

       -Wtrigraphs

       -Wno-trigraphs

              Determines  whether  warnings are issued if any trigraphs
              are encountered that might change the meaning of the pro-
              gram.

              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

       -u symbol

              Tells the compiler the specified symbol is undefined.

              Arguments:

              None

              Default:

              OFF               Standard  rules are in effect for vari-
                                ables.

              Description:

              This option tells the compiler the  specified  symbol  is
              undefined.

              Alternate Options:

              None

       -Uname
              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]

              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 and OS X: -funroll-loops

       -unroll-aggressive

       -no-unroll-aggressive

              Determines  whether  the  compiler  uses  more aggressive
              unrolling for certain loops.

              Arguments:

              None


              Alternate Options:

              None

       -use-intel-optimized-headers

              Determines whether the performance
                     headers  directory  is  added  to the include path
                     search list.

              Architecture Restrictions: Not available on  Intel(R)  64
              architecture targeting the
                     Intel(R) Xeon  Phi(TM)  coprocessor  x100  product
                     family  (formerly  code  name  Knights Corner), on
                     IA-32  architecture  targeting  Intel(R)  Graphics
                     Technology, or on Intel(R) 64 architecture target-
                     ing Intel(R) Graphics Technology

              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.


              Optimization Notice


              = = = = = = = = = =

              Intel's  compilers  may  or  may not optimize to the same
              degree for non-Intel  microprocessors  for  optimizations
              that are not unique to Intel microprocessors. These opti-
              mizations include SSE2, SSE3, and SSSE3 instruction  sets
              and  other  optimizations.  Intel  does not guarantee the
              availability,  functionality,  or  effectiveness  of  any
              optimization   on  microprocessors  not  manufactured  by
              None

       -use-msasm

              Enables  the use of blocks and entire functions of assem-
              bly 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  func-
              tions 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

              Displays the compiler version information.

              Arguments:

              None

              Default:

              OFF               The compiler version information is not
                                displayed.

              Description:

              This  option  displays the startup banner, which contains
              the following compiler information:

              · The name of the compiler and its  applicable  architec-
                ture

              · The major and minor version of the compiler, the update
                number, and the  package  number(for  example,  Version
                12.1.0.047)

              Specifies that driver tool commands should  be  displayed
              and executed.

              Arguments:

              filename          Is the name of a source file to be com-
                                piled.  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  com-
              piler.

              Alternate Options:

              None

       -vec

       -no-vec

              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* and  OS
              X*) or /Qvec- (Windows*).

              To   disable  interpretation  of  SIMD  pragmas,  specify
              -no-simd (Linux* and OS X*) or /Qsimd- (Windows*).

              To disable all compiler vectorization, use  the  "-no-vec
              [Q]x.

              Alternate Options:

              None

       -vec-guard-write

       -no-vec-guard-write

              Tells  the  compiler  to perform a conditional check in a
              vectorized loop.

              Arguments:

              None

              Default:

              -vec-guard-write  The   compiler   performs a conditional
                                check in a vectorized loop.

              Description:

              This option tells the compiler to perform  a  conditional
              check in a vectorized loop. This checking avoids unneces-
              sary stores and may improve performance.

              Alternate Options:

              None

       -vec-threshold[n]

              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  vec-
                                tor-level  parallel execution is almost
                                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  thresh-
              old  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.

              Alternate Options:

              None

       -vecabi=keyword

              Determines which vector function
                     application  binary  interface  (ABI) the compiler
                     uses to create or call vector functions.

              Arguments:

              keyword           Specifies which vector function ABI  to
                                use.  Possible values are:

                                compat         Tells  the  compiler  to
                                               use  the   compatibility
                                               vector   function   ABI.
                                               This    ABI     includes
                                               Intel(R)-specific   fea-
                                               tures.

                                cmdtarget      Tells  the  compiler  to
                                               generate an extended set
                                               of vector functions. The
                                               option  is  very similar
                                               to setting compat.  How-
                                               ever,  for  compat, only
                                               one vector  function  is
                                               created,  while for cmd-
                                               target,  several  vector
                                               functions   are  created
                                               for each vector specifi-
                                               available   on  Windows*
                                               systems.

                                legacy         Tells  the  compiler  to
                                               use  the  legacy  vector
                                               function ABI.  Use  this
                                               setting  if  you need to
                                               keep the generated  vec-
                                               tor    function   binary
                                               backward compatible with
                                               the   vectorized  binary
                                               generated by older  ver-
                                               sions  of  the  Intel(R)
                                               compilers   (V13.1    or
                                               older).

              Default:

              compat            The  compiler  uses  the  compatibility
                                vector function ABI.

              Description:

              This option determines which vector function  application
              binary  interface  (ABI)  the  compiler uses to create or
              call vector functions.

              NOTE: To avoid possible link-time  and  run-time  errors,
              use identical [Q]vecabi settings when compiling all files
              in an application that define or  use  vector  functions,
              including  libraries.  If setting cmdtarget is specified,
              options [Q]x and/or [Q]ax must have identical values.

              Be careful using setting cmdtarget with libraries or pro-
              gram  modules/routines  with  vector function definitions
              that cannot be recompiled. In such cases, setting cmdtar-
              get may cause link errors.

              On  Linux* systems, since the default is compat, you must
              specify legacy if you need to keep the  generated  vector
              function  binary  backward compatible with the vectorized
              binary generated by the previous version of Intel(R) com-
              pilers.

              When  cmdtarget is specified, the additional vector func-
              tion versions are created by copying each vector specifi-
              cation  and  changing  target  processor in the copy. The
              number of vector functions is determined by the  settings
              specified in options [Q]x and/or [Q]ax.

              For  example, suppose we have the following function dec-
              laration:
              vector
                                function specification).   Four  vector
                                versions  are created for the following
                                targets:

                                · Intel(R) SSE2 (default because no  -x
                                  option is used)

                                · Intel(R)  SSE4.1  (by vector function
                                  specification)

                                · Intel(R) AVX (by the first -ax option
                                  value)

                                · Intel(R)  AVX2  (by  the  second  -ax
                                  option value)

              For more information about the Intel(R)-compatible vector
              functions  ABI,  see  the  Vector  Function  ABI document
              available in the Open  Specifications  section  at  cilk-
              plus.org.

              For  more information about the GCC vector functions ABI,
              see the item Libmvec - vector math  library  document  in
              the GLIBC wiki at sourceware.org.


              Optimization Notice


              = = = = = = = = = =

              Intel's  compilers  may  or  may not optimize to the same
              degree for non-Intel  microprocessors  for  optimizations
              that are not unique to Intel microprocessors. These opti-
              mizations include SSE2, SSE3, and SSSE3 instruction  sets
              and  other  optimizations.  Intel  does not guarantee the
              availability,  functionality,  or  effectiveness  of  any
              optimization   on  microprocessors  not  manufactured  by
              Intel.  Microprocessor-dependent  optimizations  in  this
              product  are intended for use with Intel microprocessors.
              Certain optimizations not specific to  Intel  microarchi-
              tecture  are  reserved  for Intel microprocessors. Please
              refer to the applicable product User and Reference Guides
              for  more  information regarding the specific instruction
              sets covered by this notice.

              Notice revision #20110804

              = = = = = = = = = =

              Alternate Options:

              None

              Default:

              OFF

              Description:

              Tells the compiler to display GCC-style version  informa-
              tion.

              Alternate Options:

              None

       -w

              Disables all warning messages.

              Arguments:

              None

              Default:

              OFF               Default warning messages are enabled.

              Description:

              This option disables all warning messages.

              Alternate Options:

              Linux and OS X: -w0

              Windows: /W0

       -wn

              Specifies  the  level of diagnostic messages to be gener-
              ated by the compiler.

              Arguments:

              n                 Is  the level of diagnostic messages to
                                be generated. Possible values are:

                                0              Enables diagnostics  for
                                               errors.  Disables  diag-
                                               nostics for warnings.

                                               errors. Additional warn-
                                               ings  are  also  enabled
                                               above level 2 (n  =  2).
                                               This   level  is  recom-
                                               mended  for   production
                                               purposes.

                                4              Enables  diagnostics for
                                               all  level  3  (n  =  3)
                                               warnings  plus  informa-
                                               tional   warnings    and
                                               remarks,  which  in most
                                               cases  can   be   safely
                                               ignored.  This  value is
                                               only available  on  Win-
                                               dows* systems.

                                5              Enables  diagnostics for
                                               all  remarks,  warnings,
                                               and errors. This setting
                                               produces the most  diag-
                                               nostic   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,...]

              Passes options to the assembler for processing.

              Arguments:

              Alternate Options:

              None

       -Wabi

       -Wno-abi

              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

              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* and OS X* systems, this option is sim-
              ilar  to  gcc  option  -Wall.  It displays all errors and
              keyword...]]

       -nowatch

              Tells the compiler to display certain
                     information to the console output window.

              Arguments:

              keyword           Determines  what  information  is  dis-
                                played. 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.

                                mic-cmd        Enables display of  com-
                                               piler  options  that are
                                               passed  to  the  offload
                                               compilation.  This  key-
                                               word is  only  available
                                               on Intel(R) 64 architec-
                                               ture    targeting    the
                                               Intel(R)   Xeon  Phi(TM)
                                               coprocessor x100 product
                                               family   (formerly  code
                                               name Knights Corner).

                                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            watchkeyword Description

              none              Tells  the compiler to not display pass
                                information and source  file  names  to
                                an  architecture other than Intel(R) 64
                                architecture  targeting  the   Intel(R)
                                Xeon  Phi(TM)  coprocessor x100 product
                                family (formerly code name Knights Cor-
                                ner),  results vary. It may be ignored,
                                have no effect, or produce an error.

              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 key-
                                word.  For  heterogeneous  compilation,
                                the  tool commands for the host and the
                                offload compilations will be displayed.

              Alternate Options:

              watch cmd         Linux and OS X: -v

       -Wbrief

              Tells  the compiler to display a shorter form of diagnos-
              tic output.

              Arguments:

              None

              Default:

              OFF               The  compiler displays its normal diag-
                                nostic output.

              Description:

              This option tells the compiler to display a shorter  form
              of  diagnostic  output. In this form, the original source
              line is not displayed and the error message text  is  not
              wrapped when too long to fit on a single line.

              Alternate Options:

              Linux and OS X: None

       -Wcheck

              Tells  the compiler to perform compile-time code checking
              for certain code.

              Arguments:

              None

              Alternate Options:

              None

       -Wcomment

       -Wno-comment

              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

       -Wcontext-limit=n

              Set the maximum number of template instantiation contexts
              shown in diagnostic.

              Arguments:

              n                 Number  of  template instantiation con-
                                texts.

              Default:

              OFF

              Description:

              Set maximum number  of  template  instantiation  contexts
              shown in diagnostic.

              Alternate Options:

              None
              -Wdeprecated      The compiler issues warnings for depre-
                                cated C++ headers.

              Description:

              This option determines whether warnings  are  issued  for
              deprecated  C++  headers. It has no effect in  C compila-
              tion 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++

              Enables warnings based on certain C++ programming  guide-
              lines.

              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 com-
                ments. C comments in system headers are not  diagnosed.

              · Use  delete on pointer members in destructors. The com-
                piler diagnoses  any  pointer  that  does  not  have  a

              · 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 Pro-
                grams and Designs

              Alternate Options:

              None

       -Werror

              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:

              Linux and OS X: -diag-error warn

       -Wextra-tokens

       -Wno-extra-tokens

              Determines whether warnings are issued about extra tokens
              at the end of preprocessor directives.

              Arguments:

              None

              Default:

       -Wformat

       -Wno-format

              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

       -Wno-format-security

              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 secu-
              rity 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.

              None

              Default:

              -Wic-pointer      The compiler issues warnings  for  con-
                                versions  between  pointers to distinct
                                scalar types with the same  representa-
                                tion.

              Description:

              This  option  determines  whether warnings are issued for
              conversions between pointers  to  distinct  scalar  types
              with the same representation.

              For example, consider the following:

              void f(int *p) { long *q = p; }


              In  this  case, by default, the compiler issues a warning
              because of the conversion from pointer to int to  pointer
              to long.

              However, if you specify -Wno-ic-pointer, and long and int
              values have the same representation on the  target  plat-
              form, the warning will not be issued.

              Alternate Options:

              None

       -Winline

              Warns  when  a function that is declared as inline is not
              inlined.

              Arguments:

              None

              Default:

              OFF               No  warning is produced when a function
                                that  is  declared  as  inline  is  not
                                inlined.

              Description:

              This  option  warns  when  a function that is declared as
              inline is not inlined.
              Arguments:

              option            Is  a linker option. This option is not
                                processed by the driver and is directly
                                passed to the linker.

              Default:

              OFF               No options are passed to the linker.

              Description:

              This  option passes one or more options to the linker for
              processing. If the linker is not invoked,  these  options
              are ignored.

              This  option  is  equivalent  to  specifying option -Qop-
              tion,link,options.

              Alternate Options:

              None

       -Wmain

       -Wno-main

              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

       -Wno-missing-declarations

              Description:

              This option determines whether warnings  are  issued  for
              global functions and variables without prior declaration.

              Alternate Options:

              None

       -Wmissing-prototypes

       -Wno-missing-prototypes

              Determines whether warnings are issued for missing proto-
              types.

              Arguments:

              None

              Default:

              -Wno-missing-prototypes
                                No warnings are issued for missing pro-
                                totypes.

              Description:

              Determines whether warnings are issued for missing proto-
              types.

              If -Wmissing-prototypes is specified, it tells  the  com-
              piler 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.

              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 preproces-
                                sor.

              Description:

              This option passes one or more options to the  preproces-
              sor.  If  the  preprocessor is not invoked, these options
              are ignored.

              This option is  equivalent  to  specifying  option  -Qop-
              tion,cpp, options.

              Alternate Options:

              None

       -Wp64

              Tells  the  compiler  to  display  diagnostics for 64-bit
              porting.

              Arguments:

              None

              Default:

              OFF               The  compiler does not display diagnos-
                                tics for 64-bit porting.

              Description:

              This option tells the compiler to display diagnostics for
              64-bit porting.

              Alternate Options:

              None

       -Wpch-messages

       -Wno-pch-messages

              This option determines whether the compiler shows precom-
              piled  header  (PCH)  informational messages. By default,
              these messages are displayed.

              To suppress the display of  the  PCH  informational  mes-
              sages,  specify  -Wno-pch-messages  (Linux* and OS X*) or
              /Wpch-messages- (Windows*).

              Alternate Options:

              None

       -Wpointer-arith

       -Wno-pointer-arith

              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

       -Wremarks

              Tells the compiler to display remarks and comments.

              Arguments:

              None

              Default:

              OFF               Default warning messages are enabled.

              Description:

              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

       -Wno-return-type

              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 con-
                tains a return statement with an expression

              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 declara-
                                tion.

              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

       -Wno-sign-compare

              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 warn-
                                ings

              Description:

              This option determines whether warnings are issued when a
              comparison between signed and unsigned values could  pro-
              duce  an  incorrect  result when the signed value is con-
              verted to unsigned.

              On Linux* systems, this option is provided  for  compati-
              bility with gcc.

              Alternate Options:
              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 –ansi-alias or option –fstrict-aliasing.

              Alternate Options:

              None

       -Wstrict-prototypes

       -Wno-strict-prototypes

              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

       -Wno-trigraphs

              Determines  whether  warnings are issued if any trigraphs
              are encountered that might change the meaning of the pro-
              This option determines whether warnings are issued if any
              trigraphs are encountered that might change  the  meaning
              of the program.

              Alternate Options:

              None

       -Wuninitialized

       -Wno-uninitialized

              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

       -Wno-unknown-pragmas

              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:

              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

       -Wno-unused-variable

              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

              Issues a diagnostic message if const char * is  converted
              This option issues a diagnostic message if const char* is
              converted to (non-const) char *.

              Alternate Options:

              None

       -x type

              All source files found subsequent to -x type will be rec-
              ognized 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  rec-
              ognized as a particular type.

              Alternate Options:

              None

              Arguments:

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

                                COMMON-AVX512  May   generate  Intel(R)
                                               Advanced  Vector  Exten-
                                               sions    512   (Intel(R)
                                               AVX-512)      Foundation
                                               instructions,   Intel(R)
                                               AVX-512 Conflict  Detec-
                                               tion   instructions,  as
                                               well as the instructions
                                               enabled  with CORE-AVX2.
                                               Optimizes  for  Intel(R)
                                               processors  that support
                                               Intel(R)         AVX-512
                                               instructions.

                                MIC-AVX512     May   generate  Intel(R)
                                               Advanced  Vector  Exten-
                                               sions    512   (Intel(R)
                                               AVX-512)      Foundation
                                               instructions,   Intel(R)
                                               AVX-512 Conflict  Detec-
                                               tion       instructions,
                                               Intel(R)  AVX-512  Expo-
                                               nential  and  Reciprocal
                                               instructions,   Intel(R)
                                               AVX-512         Prefetch
                                               instructions         for
                                               Intel(R) processors, and
                                               the instructions enabled
                                               with   CORE-AVX2.  Opti-
                                               mizes for Intel(R)  pro-
                                               cessors   that   support
                                               Intel(R)         AVX-512
                                               instructions.

                                               This   keyword  is  only
                                               available  on   Windows*
                                               and Linux* systems.

                                CORE-AVX512    May   generate  Intel(R)
                                               Advanced  Vector  Exten-
                                               sions    512   (Intel(R)
                                               processors that  support
                                               Intel(R)         AVX-512
                                               instructions.

                                CORE-AVX2      May  generate   Intel(R)
                                               Advanced  Vector  Exten-
                                               sions 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  instruc-
                                               tions.

                                CORE-AVX-I     May  generate   Float-16
                                               conversion  instructions
                                               and the  RDRND  instruc-
                                               tion,  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  Exten-
                                               sions  (Intel(R)   AVX),
                                               Intel(R) SSE4.2, SSE4.1,
                                               SSE3,  SSE2,  SSE,   and
                                               SSSE3  instructions  for
                                               Intel(R)     processors.
                                               Optimizes for Intel pro-
                                               cessors   that   support
                                               Intel(R)   AVX  instruc-
                                               tions.

                                SSE4.2         May  generate   Intel(R)
                                               SSE4  Efficient Acceler-
                                               ated  String  and   Text
                                               Processing instructions,
                                               Intel(R) SSE4  Vectoriz-
                                               ing  Compiler  and Media
                                               Accelerator,         and
                                               Intel(R)   SSE3,   SSE2,
                                               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* and  OS  X*)  or
                                               /Qinstruction      (Win-
                                               dows*). May also  gener-
                                               ate   Intel(R)   SSE4.2,
                                               SSE3,  SSE2,   and   SSE
                                               instructions  for  Intel
                                               processors.    Optimizes
                                               for   Intel(R)  Atom(TM)
                                               processors that  support
                                               Intel(R)    SSE4.2   and
                                               MOVBE instructions.

                                               This  keyword  is   only
                                               available   on  Windows*
                                               and Linux* systems.

                                ATOM_SSSE3     May    generate    MOVBE
                                               instructions         for
                                               Intel(R)     processors,
                                               depending on the setting
                                               of option  -minstruction
                                               (Linux*  and  OS  X*) or
                                               /Qinstruction      (Win-
                                               dows*).  May also gener-
                                               ate   SSSE3,    Intel(R)
                                               SSE3,   SSE2,   and  SSE
                                               instructions  for  Intel
                                               processors.    Optimizes
                                               for  Intel(R)   Atom(TM)
                                               processors  that support
                                               Intel(R) SSE3 and  MOVBE
                                               instructions.

                                               This   keyword  is  only
                                               available  on   Windows*
                                               and Linux* systems.

                                SSE3_ATOM and  SSSE3_ATOM  These option
                                               settings are deprecated.
                                               They   have   the   same
                                               effect   as   specifying
                                               ATOM_SSSE3.

                                SSE3           May   generate  Intel(R)
                                               SSE3,  SSE2,   and   SSE
                                               instructions         for
                                               Intel(R)     processors.
                                               Optimizes for Intel pro-
                                               cessors   that   support
                                               Intel(R)  SSE3  instruc-
                                               tions. For  OS  X*  sys-
                                               tems, this value is only
                                               supported    on    IA-32
                                               architecture.

                                SSE2           May   generate  Intel(R)
                                               SSE2  and  SSE  instruc-
                                               tions  for Intel(R) pro-
                                               cessors.  Optimizes  for
                                               Intel   processors  that
                                               support  Intel(R)   SSE2
                                               instructions. This value
                                               is not available  on  OS
                                               X* systems.

                                You  can  also  specify  Host. For more
                                information, see option [Q]xHost.

              Default:

              Windows* systems: None Linux* systems: None OS X* systems
              using IA-32
                                architecture: SSE3 OS X* systems  using
                                Intel(R) 64 architecture: SSSE3 On Win-
                                dows systems, if neither /Qx nor  /arch
                                is    specified,    the    default   is
                                /arch:SSE2.

                                On Linux systems, if neither -x nor  -m
                                is specified, the default is -msse2.

              Description:

              This  option  tells the compiler which processor features
              it may target, including which instruction sets and opti-
              mizations  it may generate. It also enables optimizations
              in addition to Intel feature-specific optimizations.

              The specialized code generated by this  option  may  only
              run on a subset of Intel(R) processors.

              The  resulting executables created from these option code
              values can only be run on Intel(R) processors  that  sup-
              port the indicated instruction set.

              Compiler options m and arch produce binaries that  should
              run  on  processors  not made by Intel that implement the
              same capabilities as the corresponding  Intel(R)  proces-
              sors.

              The  -x  and  /Qx options enable additional optimizations
              not enabled with options -m or /arch  (nor  with  options
              –ax and /Qax).

              On  Windows  systems,  options /Qx and /arch are mutually
              exclusive. If both are specified, the compiler  uses  the
              last one specified and generates a warning. Similarly, on
              Linux and OS X systems, options -x and  -m  are  mutually
              exclusive.  If  both are specified, the compiler uses the
              last one specified and generates a warning.

              NOTE: All settings except SSE2 do a CPU  check.  However,
              if  you  specify  option –O0 (Linux* or OS X*) or option
              /Od (Windows*), no CPU check is performed.


              Optimization Notice


              = = = = = = = = = =

              Intel's compilers may or may not  optimize  to  the  same
              degree  for  non-Intel  microprocessors for optimizations
              that are not unique to Intel microprocessors. These opti-
              mizations  include SSE2, SSE3, and SSSE3 instruction sets
              and other optimizations. Intel  does  not  guarantee  the
              availability,  functionality,  or  effectiveness  of  any
              optimization  on  microprocessors  not  manufactured   by
              Intel.  Microprocessor-dependent  optimizations  in  this
              product are intended for use with Intel  microprocessors.
              Certain  optimizations  not specific to Intel microarchi-
              tecture are reserved for  Intel  microprocessors.  Please
              refer to the applicable product User and Reference Guides
              for more information regarding the  specific  instruction
              sets covered by this notice.

              Notice revision #20110804

              = = = = = = = = = =

              Alternate Options:

              None

       -X

              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* and OS X* systems,  specifying  -X  (or  -noin-
              clude)   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 and OS X: -nostdinc

       -xHost

              Tells the compiler to generate
                     instructions   for  the  highest  instruction  set
                     available on the compilation host processor.

              Architecture Restrictions: Not available on  Intel(R)  64
              architecture targeting the
                     Intel(R) Xeon  Phi(TM)  coprocessor  x100  product
                     family  (formerly  code  name  Knights Corner), on
                     IA-32  architecture  targeting  Intel(R)  Graphics
                     Technology, or on Intel(R) 64 architecture target-
                     ing Intel(R) Graphics Technology

              Arguments:

              None

              Default:

              Windows* systems: None Linux* systems: None OS X* systems
              using IA-32
                                architecture:  -xSSE3  OS  X*   systems
                                using Intel(R) 64 architecture: -xSSSE3
                                On Windows systems, if neither /Qx  nor
                                /arch  is  specified,  the  default  is
                                /arch:SSE2.

                                On Linux systems, if neither -x nor  -m
                                is specified, the default is -msse2.

              Description:

              This  option  tells the compiler to generate instructions
              for the highest instruction set available on the compila-
              SIMD Extensions (SSSE).

              Instruction Set of Host Processor
                                  Effects  When  the  -xHost or /QxHost
                                Compiler Option is Specified

              Intel(R) AVX-512  When  compiling   for   Intel(R)   Xeon
                                Phi(TM)  coprocessor (code name Knights
                                Landing),   corresponds    to    option
                                [Q]xMIC-AVX512.   The   generated  exe-
                                cutable will not run on non-Intel  pro-
                                cessors  and  it  will not run on Intel
                                processors that do not support  all  of
                                Intel(R)  AVX-512  foundation, conflict
                                detection,  prefetch,  and  exponential
                                and reciprocal instructions.

              Intel(R) AVX2     When compiling on Intel(R) processors:

              Corresponds to option
                                [Q]xCORE-AVX2. The generated executable
                                will not run  on  non-Intel  processors
                                and it will not run on Intel(R) proces-
                                sors that do not support Intel(R)  AVX2
                                instructions.

              When compiling on non-Intel processors:

              Corresponds to option
                                -march=core-avx2  (Linux* and OS X*) or
                                /arch:CORE-AVX2 (Windows*). The  gener-
                                ated  executable  will  run on Intel(R)
                                processors  and  non-Intel   processors
                                that  support  at  least  Intel(R) AVX2
                                instructions.. You may see  a  run-time
                                error  if  the  run-time processor does
                                not support Intel(R) AVX2 instructions.

              Intel(R) AVX      When compiling on Intel(R) processors:

              Corresponds to option
                                [Q]xAVX.  The generated executable will
                                not run on non-Intel processors and  it
                                will  not  run  on  Intel(R) processors
                                that  do  not  support   Intel(R)   AVX
                                instructions.

              When compiling on non-Intel processors:

              Corresponds to option
                                -mavx  (Linux  and  OS  X) or /arch:AVX
                                (Windows).  The  generated   executable
                                SSE4.2 instructions.

              When compiling on non-Intel processors:

              Corresponds to option
                                -msse4.2   (Linux   and   OS   X)    or
                                /arch:SSE4.2  (Windows).  The generated
                                executable will run on Intel(R) proces-
                                sors and non-Intel processors that sup-
                                port at least Intel(R) SSE4.2  instruc-
                                tions.  You may see a run-time error if
                                the run-time processor does not support
                                Intel(R) SSE4.2 instructions.

              Intel(R) SSE4.1   When compiling on Intel(R) processors:

              Corresponds to option
                                [Q]xSSE4.1.  The  generated  executable
                                will not run  on  non-Intel  processors
                                and it will not run on Intel(R) proces-
                                sors  that  do  not  support   Intel(R)
                                SSE4.1 instructions.

              When compiling on non-Intel processors:

              Corresponds to option
                                -msse4.1    (Linux   and   OS   X)   or
                                /arch:SSE4.1 (Windows).  The  generated
                                executable will run on Intel(R) proces-
                                sors and non-Intel processors that sup-
                                port  at least Intel(R) SSE4.1 instruc-
                                tions. You may see a run-time error  if
                                the run-time processor does not support
                                Intel(R) SSE4.1 instructions.

              SSSE3             When compiling on Intel(R) processors:

              Corresponds to option
                                [Q]xSSSE3.  The  generated   executable
                                will  not  run  on non-Intel processors
                                and it will not run on Intel(R) proces-
                                sors that do not support SSSE3 instruc-
                                tions.

              When compiling on non-Intel processors:

              Corresponds to option
                                -mssse3 (Linux and OS X) or /arch:SSSE3
                                (Windows).   The  generated  executable
                                will run  on  Intel(R)  processors  and
                                non-Intel  processors  that  support at
                                least SSSE3 instructions. You may see a

              Corresponds to option
                                -msse3  (Linux  and OS X) or /arch:SSE3
                                (Windows).  The  generated   executable
                                will  run  on  Intel(R)  processors and
                                non-Intel processors  that  support  at
                                least  Intel(R)  SSE3 instructions. You
                                may see a warning run-time error if the
                                run-time  processor  does  not  support
                                Intel(R) SSE3 instructions.

              Intel(R) SSE2     When compiling on  Intel(R)  processors
                                or non-Intel processors:

              Corresponds to option
                                -msse2  (Linux  and OS X) or /arch:SSE2
                                (Windows).  The  generated   executable
                                will  run  on  Intel(R)  processors and
                                non-Intel processors  that  support  at
                                least  Intel(R)  SSE2 instructions. You
                                may  see  a  run-time  error   if   the
                                run-time  processor  does  not  support
                                Intel(R) SSE2 instructions.

              For more information on other settings for  option  [Q]x,
              see that option description.


              Optimization Notice


              = = = = = = = = = =

              Intel's  compilers  may  or  may not optimize to the same
              degree for non-Intel  microprocessors  for  optimizations
              that are not unique to Intel microprocessors. These opti-
              mizations include SSE2, SSE3, and SSSE3 instruction  sets
              and  other  optimizations.  Intel  does not guarantee the
              availability,  functionality,  or  effectiveness  of  any
              optimization   on  microprocessors  not  manufactured  by
              Intel.  Microprocessor-dependent  optimizations  in  this
              product  are intended for use with Intel microprocessors.
              Certain optimizations not specific to  Intel  microarchi-
              tecture  are  reserved  for Intel microprocessors. Please
              refer to the applicable product User and Reference Guides
              for  more  information regarding the specific instruction
              sets covered by this notice.

              Notice revision #20110804

              = = = = = = = = = =

              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


              Alternate Options:

              None

       -Zp[n]

              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

       The Intel(R) C++ Compiler documentation describes the predefined
       macros in detail. This section provides a brief summary  of  the
       currently in effect for the specified name. This option performs
       the same function as an #undef preprocessor directive.

       The following table lists the predefined macros on systems based
       on either the IA-32 or Intel(R) 64 architecture.


       Macro              Description

       __APPLE__ (OS X*) 1

       __APPLE_CC__ (OS X*)
                         gcc* build number

       __ARRAY_OPERATORS (Linux*)
                         1

       __AVX__ (Windows*, Linux*)
                         Defined  and value to '1' with /arch:AVX (Win-
                         dows*)  or   –march=corei7-avx  or     –mavx
                         (Linux*),  or [Q]xAVX or higher processor tar-
                         geting options.


              NOTE:
              Available only for  compilations  targeting  Intel(R)  64
              architecture.

       __AVX2__ (Windows*, Linux*)
                         Defined  and  value to '1' with arch:CORE-AVX2
                         (Windows*)  or  march=core-avx2  (Linux*),  or
                         [Q]xCORE-AVX2  or  higher  processor targeting
                         options.


              NOTE:
              Available only for  compilations  targeting  Intel(R)  64
              architecture.

       __AVX512BW__ (Windows*,
                         Linux*,  OS  X*) Defined as '1' for processors
                         that support Intel(R) Advanced  Vector  Exten-
                         sions  512  (Intel(R)  AVX-512)  Byte and Word
                         instructions.

       It is also defined as '1' when option [Q]xCORE-AVX512 or
                         higher processor-targeting options are  speci-
                         fied.

       __AVX512CD__      (Windows*,  Linux*,  OS X*) Defined as '1' for
                         processors that support Intel(R) Advanced Vec-
                         tor Extensions 512 (Intel(R) AVX-512) Conflict

       __AVX512ER__ (Windows*,
                         Linux*,  OS  X*) Defined as '1' for processors
                         that support Intel(R) Advanced  Vector  Exten-
                         sions  512  (Intel(R) AVX-512) Exponential and
                         Reciprocal instructions.

       It is also defined as '1' when option [Q]xMIC-AVX512 or
                         higher processor-targeting options are  speci-
                         fied.

       __AVX512F__ (Windows*,
                         Linux*,  OS  X*) Defined as '1' for processors
                         that support Intel(R) Advanced  Vector  Exten-
                         sions   512   (Intel(R)   AVX-512)  Foundation
                         instructions.

       It is also defined as '1' when option [Q]xCORE-AVX512,
                         [Q]xCOMMON-AVX512,  [Q]xMIC-AVX512  or  higher
                         processor-targeting options are specified.

       __AVX512PF__      (Windows*,  Linux*,  OS X*) Defined as '1' for
                         processors that support Intel(R) Advanced Vec-
                         tor Extensions 512 (Intel(R) AVX-512) Prefetch
                         instructions.

       It is also defined as when option [Q]xMIC-AVX512 or higher
                         processor-targeting options are specified.

       __AVX512VL__ (Windows*,
                         Linux*, OS X*) Defined as '1'  for  processors
                         that  support  Intel(R) Advanced Vector Exten-
                         sions 512  (Intel(R)  AVX-512)  Vector  Length
                         extensions.

       It is also defined as '1' when option [Q]xCORE-AVX512 or
                         higher  processor-targeting options are speci-
                         fied.

       __BASE_FILE__ (Linux*)
                         Name of source file

       __cilk (Windows*, Linux*)
                         200; however, if you specify [Q]cilk-serialize
                         or  the  negative form of [Q]intel-extensions,
                         the value is undefined.

       __cplusplus (Linux*)
                         1 (with C++ compiler)

       __DEPRECATED (Linux*)
                         1
                         not used.

       __extension__ (Linux*)


       __gnu_linux__ (Linux*)
                         1

       __GFX__ (Windows*, Linux*)
                         You  can  use  this macro to protect code that
                         should only be compiled for  and  executed  on
                         Intel(R) Graphics Technology.

       Defined by default. Builds code that runs on the CPU and the
                         target,  but this macro is only defined during
                         the target compilation. Undefined when you use
                         the negative form of the [Q]offload option.

       __GNUC__ (Linux*) The  major version number of gcc* installed on
                         the system.

       __GNUC_MINOR__ (Linux*)
                         The minor  version  number  of  gcc*  or  g++*
                         installed on the system.

       __GNUC_PATCHLEVEL__ (Linux*)
                         The patch level version number of gcc* or g++*
                         installed on the system.

       __GNUG__ (Linux*) The major version number of g++* installed  on
                         the system.

       __GXX_ABI_VERSION (Linux*)
                         102 (Linux*)

       __HONOR_STD (Linux*, OS X*)
                         1

       __i386 (Linux*, OS X*)

       __i386__ (Linux*, OS X*)

       i386 (Linux*, OS X*)
                         1


              NOTE:
              Available only for compilations targeting IA-32 architec-
              ture.

       __INTEL_COMPILER (Linux*, OS X*)

       __INTEL_COMPILER_BUILD_DATE (Windows*,
                         Linux*, OS X*) YYYYMMDD

       __INTEL_CXX11_MODE__ (Windows*, Linux*)
                         Enables C++11  experimental  support  for  C++
                         programs.

       Defined as '1'    when [Q]std=c++11 is specified.

       __INTEL_COMPILER_UPDATE
                         Returns the current minor update number of the
                         Intel(R) C++ Compiler, starting  at  0.  (Win-
                         dows*, Linux*, OS X*)

       You can use this  macro   to   differentiate   between  compiler
                         updates when you have multiple updates of  the
                         Intel(R)  C++ Compiler installed concurrently.

        Example:         Intel(R)  C++  Compiler  version  XX.0.2,  the
                         macro would preprocess to “2”.

       __INTEL_OFFLOAD   Defined  by the compiler when building code to
                         run on the CPU and on the  coprocessor.  (Win-
                         dows*, Linux*)

       You can use this  macro in conjunction with the negative form of
                         the [Q]offload compiler option,  or  the  Qmic
                         (Windows*) or mmic (Linux*) compiler option to
                         protect code on the host that should  only  be
                         executed  for  an offload build, such as calls
                         to the  omp_set_num_threads_target  family  of
                         APIs in offload.h.

       Defined  by  default.  Builds  code that runs on the CPU and the
       coprocessor. Undefined when you use the negative form of the
                         [Q]offload   compiler   option,  or  the  Qmic
                         (Windows*) or mmic (Linux*) compiler option.

       __INTEL_RTTI__ (Linux*, OS X*)
                         Defined as '1' when  option  fno-rtti  is  not
                         specified.

       __INTEL_STRICT_ANSI__ (Linux*, OS X*)
                         Defined  as  '1'  when  option  strict-ansi is
                         specified.

       __KNC__           This macro is similar to __MIC__,  but  it  is
                         defined by the compiler while building code to
                         run on the variant of the Intel(R) MIC  Archi-
                         tecture  known  as  the  Intel(R) Xeon Phi(TM)
                         coprocessor. (Windows*, Linux*)


       __LONG_DOUBLE_64__ (Linux*)
                         When this macro is defined,  the  long  double
                         type is 64-bits.

       Defined when you use option
                         mlong-double with 64 as an argument.

       __LONG_MAX__ (Linux*)
                         9223372036854775807L


              NOTE:
              Available  only  for  compilations  targeting Intel(R) 64
              architecture.

       __LP64__ (Linux*) 1


              NOTE:
              Available only for  compilations  targeting  Intel(R)  64
              architecture.

       __MACH__ (OS X*)  1

       __MIC__           Defined by the compiler while building code to
                         run on the coprocessor. (Windows*, Linux*)

       You can use this  macro to protect code that should only be com-
                         piled  for  and  executed  on the coprocessor,
                         such as intrinsic functions that only  run  on
                         Intel(R)  MIC Architecture, or the correspond-
                         ing header files, such as zmmintrin.h.

       Defined by default. Builds code that runs on  the  CPU  and  the
       coprocessor, but this
                         macro is only defined during  the  coprocessor
                         compilation.  Undefined when you use the nega-
                         tive form of the [Q]offload option.

       To build code that runs only on the coprocessor, use the
                         Qmic  (Windows*)  or  mmic  (Linux*)  compiler
                         option.

       This              macro  is defined when you use Qmic (Windows*)
                         or mmic (Linux*).

       __MMX__ (Linux*, OS X*)
                         1

       __NO_INLINE__ (Linux*, OS X*)


       See               offload.

       __OPTIMIZE__ (Linux*, OS X*)
                         1

       __pentium4 (Linux*, OS X*)

       __pentium4__ (Linux*, OS X*)
                         1

       __PIC__ (Linux*, OS X*)

       __pic__ (Linux*)  1 (OS X*)

       Defined as        '1' when option fPIC is specified. (Linux*)

       __PTRDIFF_TYPE__ (Linux*, OS X*)
                         int on IA-32 architecture; long on Intel(R) 64
                         architecture (Linux*)

       int / long (OS X*)

       __QMSPP_ (Windows*, OS X*)
                         1

       __REGISTER_PREFIX__ (Linux*, OS X*)


       __SIGNED_CHARS__ (Windows*, Linux*, OS X*)
                         1

       __SIZE_TYPE__ (Linux*, OS X*)
                         unsigned  on IA-32 architecture; unsigned long
                         on Intel(R) 64 architecture (Linux*)

       unsigned long (OS X*)

       __SSE__ (Windows*, Linux*, OS X*)
                         Defined as '1' for processors that support SSE
                         instructions. (Linux* and OS X*)

       Defined and value to
                         '1', only undefined when /arch:IA32 (Windows*)

       __SSE2__ (Windows*, Linux*, OS X*)
                         Defined as '1'  for  processors  that  support
                         Intel(R) SSE2 instructions. (Linux* and OS X*)

       Defined and value to
                         '1' by  default  or  with  arch:SSE2,  QxSSE2,
                         QaxSSE2  or higher processor targeting options

       Defined and value to
                         '1' with  /arch:SSE4.1,  /QxSSE4.1  or  higher
                         processor targeting options (Windows*)

       __SSE4_2__ (Windows*, Linux*)
                         Defined  as  '1'  for  processors that support
                         SSSE4 instructions. (Linux*)

       Defined and value to
                         '1' with arch:SSE4.2, QxSSE4.2 or higher  pro-
                         cessor targeting options (Windows*)

       __SSSE3__ (Windows*, Linux*, OS X*)
                         Defined  as  '1'  for  processors that support
                         SSSE3 instructions. (Linux* and OS X*)

       Defined and value to
                         '1' with arch:SSSE3, QxSSSE3 or higher proces-
                         sor targeting options (Windows*)

       __STDC__ (OS X*)  1

       __STDC_HOSTED__ (OS X*)
                         1

       __TARGET_ARCH_MIC (Windows*, Linux*)
                         Defined  as  '1' while building code to run on
                         the Intel(R) Xeon  Phi(TM)  coprocessor  (code
                         name  Knights Landing) during offload compila-
                         tion.

       It is defined by default when you specify
                         -qoffload-arch=mic-avx512  (Linux*)  or  /Qof-
                         fload-arch=mic-avx512 (Windows*).

       You can specify this symbol to protect code
                         that  should only be compiled for and executed
                         on  the  Intel(R)  Xeon  Phi(TM)  (code   name
                         Knights Landing) during offloading.

       __USER_LABEL_PREFIX__ (Linux*, OS X*)


       __VERSION__ (Linux*, OS X*)
                         Intel(R) C++ Compiler version string

       __WCHAR_MAX__ (OS X*)
                         2147483647

       __WCHAR_T (Linux*)
                         1


              NOTE:
              Available only for  compilations  targeting  Intel(R)  64
              architecture.

       _BOOL (Linux*)    1

       _LP64 (Linux*)    1


              NOTE:
              Available  only  for  compilations  targeting Intel(R) 64
              architecture.

       _MT (Windows*, Linux*)
                         1 when multithreaded DLL or  library  is  used
                         (MD[d] or MT[d] specified) (Windows*)

       1 (Linux*)


              NOTE:
              On  Linux*,  available  only  for  compilations targeting
              Intel(R) 64 architecture.

       _OPENMP (Windows*, Linux*, OS X*)
                         201307 when you specify option [Q]openmp.

       _PGO_INSTRUMENT (Windows*, Linux*)
                         '1' when options [Q]cov-gen or [Q]prof-gen are
                         specified.

       _PLACEMENT_DELETE (Linux*)
                         1

       unix (Linux*)

       __unix (Linux*)

       __unix__ (Linux*) 1


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:

                         using icc

       ICPCCFG           Specifies the configuration file for customiz-
                         ing compilations when  invoking  the  compiler
                         using icpc

       ICLCFG (OS X*)    Specifies the configuration file for customiz-
                         ing compilations when  invoking  the  compiler
                         using icl

       ICLXXCFG (OS X*)  Specifies the configuration file for customiz-
                         ing compilations when  invoking  the  compiler
                         using icl++ only.

       ICLCFG (Windows)  Specifies a configuration file, which the com-
                         piler should use instead of the  default  con-
                         figuration file.

       INTEL_LICENSE_FILE
                         Specifies  the  location for the Intel license
                         file.

       __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 icl.cfg.


              NOTE:
              By  default,  a  configuration  file  named icl.cfg (Win-
              dows*), icc.cfg (Linux*, OS X*), or icpc.cfg (Linux*,  OS
              X*)  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 ICLCFG (Windows*), ICC-
              CFG (Linux*, OS X*), or ICPCCFG (Linux*, OS X*)  environ-
              ment  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 com-
                         mand line is built as follows:

        Syntax:(On Windows, use
                         Linux or OS X use  icc)icc<PRE  flags>  <flags
                         from  configuration file> <flags from the com-
                         piler invocation> <POST flags>

       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, OS X) 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).

       DYLD_LIBRARY_PATH (OS X*)
                         Specifies the path for dynamic libraries.

       LIB (Windows*)    Specifies  the  directories  for all libraries
                         used by the compiler and linker.

        Intel(R) MIC Architecture Environment Variables

       MIC_LIBRARY_PATH  Specifies the location on the  host  for  tar-
                         get-specific  static  libraries  for  Intel(R)
                         Xeon Phi(TM) coprocessor x100  product  family
                         (formerly  code  name  Knights  Corner).   Use
                         LIBRARY_PATH for the location of host-specific
                         static  libraries  on a host system, including
                         those for the Intel(R) Xeon Phi(TM)  coproces-
                         sor (code name Knights Landing).

        GNU Environment Variables
                         and Extensions

       CPATH (Linux* and OS X*)
                         Specifies  the  path  to include directory for
                         C/C++ compilations.

       C_INCLUDE_PATH (Linux* and OS X*)
                         Specifies path to include directory for C com-
                         pilations.

       CPLUS_INCLUDE_PATH (Linux* and OS X*)
                         Specifies  path  to  include directory for C++
                         compilations.

       DEPENDENCIES_OUTPUT (Linux* and OS X*)
                         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*)
                         of       -gcc-name=directory-name/gcc       or
                         -gxx-name=directory-name/g++.

       GXX_ROOT (Linux*) Specifies the location of  the  gcc  binaries.
                         Set  this variable to specify the locations of
                         the gcc installed files when the compiler does
                         not find the needed values as specified by the
                         use   of    -gcc-name=directory-name/gcc    or
                         -gxx-name=directory-name/g++.

       LIBRARY_PATH (Linux* and OS X*)
                         Specifies  the  path  for libraries to be used
                         during the link phase.

       SUNPRO_DEPENDENCIES (Linux*)
                         This variable is the same as DEPENDENCIES_OUT-
                         PUT,  except  that system header files are not
                         ignored.

   Compiler Run-Time Environment
       Variables

       The following table summarizes  compiler  environment  variables
       that are recognized at run time.

       Run-Time Environment Variable
                          Description

       INTEL_CHKP_REPORT_MODE (Linux*)
                         Changes  the pointer checker reporting mode at
                         runtime.

       See Finding and Reporting
                         Out-of-Bounds Errors.

        GNU extensions (recognized
                         by the Intel(R) OpenMP compatibility library)

       GOMP_CPU_AFFINITY (Linux*)
                         GNU  extension  recognized  by  the   Intel(R)
                         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 envi-
                         ronment variable, see Thread  Affinity  Inter-
                         face.

        Default: Affinity is disabled
                         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  con-
                         struct 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).  Other-
              wise, 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 print-
                         ing to stderr of the OpenMP version number and
                         the values associated with the OpenMP environ-
                         ment 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
                         parallelpragma can override this variable.

       If no device with the specified device number exists, the
                         code is executed on the host. If this environ-
                         ment 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_NESTED=true

       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 par-
                         allel  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 inte-
                         ger 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
                         and OS X), or Qparallel (Windows) or qparallel
                         (Linux and OS X..

        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

       #      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  under-
                         stood  by  the  execution and runtime environ-
                         ment:


       · 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.

       · 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 determina-
                         tion   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 paren-
                         theses 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 pro-
       cessor on the target platform the behavior is implementa-
       tion-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 corre-
                         sponding  nested  level. Enables (true)
                         or  disables  (false)  the  binding  of

       OpenMP*
                         threads  between OpenMP* places, thread
                         affinity  is  disabled,  and  proc_bind
                         clauses   on  parallel  constructs  are
                         ignored. Otherwise, the execution envi-
                         ronment 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         master,  all  threads  are bound to the
                         same place as the master thread. If set
                         to  close, threads are bound to succes-
                         sive places, close to where the  master
                         thread  is bound. If set to spread, the
                         master thread's partition is subdivided
                         and  threads  are bound to single place
                         successive sub-partitions.

       NOTE: KMP_AFFINITY takes precedence over  GOMP_CPU_AFFIN-
       ITY  and  OMP_PROC_BIND.   GOMP_CPU_AFFINITY takes prece-
       dence over OMP_PROC_BIND.

       OMP_SCHEDULE      Sets the run-time schedule type and  an
                         optional chunk size.

        Default:STATIC, no chunk
                         size specified

        Example syntax:OMP_SCHEDULE="kind[,chunk_size]"

       = = = = = = = = = =

       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. Recom-
                         mended size is 16M.

       Use the optional suffixes to specify byte
                         units:  B  (bytes),  K  (Kilobytes),  M
                         (Megabytes),  G (Gigabytes), or T (Ter-
                         abytes) to specify the  units.  If  you
                         specify  a  value without a suffix, the
                         byte unit is assumed  to  be  K  (Kilo-
                         bytes).
                         erwise,  calling  kmp_set_stacksize_s()
                         has no effect.

        Default (IA-32 architecture): 2M

        Default (Intel(R) 64 architecture):
                         4M

        Default (Intel(R) MIC
                         architecture):4M (on supported OSes)

        Related environment variables:KMP_STACKSIZE
                         (overrides OMP_STACKSIZE).

        Syntax:OMP_STACKSIZE=value

       OMP_THREAD_LIMIT  Limits   the   number   of   simultane-
                         ously-executing  threads  in an OpenMP*
                         program.

       If this limit is reached and another
                         native operating system thread  encoun-
                         ters  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 gen-
                         erated 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  follow-
                         ing   options:   Qopenmp  (Windows)  or
                         qopenmp (Linux and OS X), or  Qparallel
                         (Windows)  or  qparallel  (Linux and OS
                         X).

       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 wait-
                         ing.

                         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,respect,granular-
                         ity=core,duplicates,none

        Default (Intel(R) MIC
                         architecture):          noverbose,warn-
                         ings,respect,granularity=fine,dupli-
                         cates,scatter,0,0

       = = = = = = = = = =

       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.  = =
       = = = = = = = =

       KMP_ALL_THREADS   Limits   the   number   of   simultane-
                         ously-executing  threads  in an OpenMP*
                         program. If this limit is  reached  and
                         another  native operating system thread
                         encounters OpenMP* API  calls  or  con-
                         structs,  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  mes-
                         sage  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.

       = = = = = = = = = =

       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.  = =
       = = = = = = = =

       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 consis-
                         tent floating point result from run  to
                         run, since round-off errors are identi-
                         cal.

        Default:false

       KMP_DYNAMIC_MODE  Selects the method  used  to  determine
                         the number of threads to use for a par-
                         allel  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  (IA-32  architecture):load_balance (on all sup-
       ported OSes)

        Default  (Intel(R) 64 architecture):load_balance (on all
       supported OSes)

        Default (Intel(R) MIC
                         architecture):  thread_limit  (on  sup-
                         enabled.

        Default: 1

       KMP_HOT_TEAMS_MODE
                         Specifies the  run-time  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  sub-
                           sequent parallel regions.

        Default: 0

       KMP_HW_SUBSET     Specifies  the number of sockets, cores
                         per socket, and the number  of  threads
                         per core, to use with an OpenMP* appli-
                         cation, as an  alternative  to  writing
                         explicit affinity settings or a process
                         affinity mask.  You can also specify an
                         offset  value  to set which sockets and
                         cores to use.

        Syntax:socketsS[@offset],coresC[@offset],threadsT

       S, C and T are not case-sensitive.


       sockets           The number of sockets to use.

       cores             The number of cores to use per  socket.

       threads           The  number of threads to use per core.

       offset            (Optional) The  number  of  sockets  or
                         cores to skip.

       NOTE: If you don't specify one or more types of resource,
       sockets, cores or threads,  all  available  resources  of
       that type are used.

       NOTE: This variable does not work if the OpenMP* affinity
       is set to none, the default on Intel(R)  Xeon(R)  proces-
       sors,  or  disabled. Set the affinity type by setting the
       environment variable OMP_PROC_BIND to a value other  than
       false,  or by setting the environment variable KMP_AFFIN-
                           socket  (c0  - c3), and 2 threads per
                           core.

                         · 2s@2,4c@8,2t: Skip the first 2  sock-
                           ets  (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.

                         · 2T:  Use  all cores on all sockets, 2
                           threads per core.

                         · 4C@12: Use 4 cores  with  offset  12,
                           all available threads per core.

       KMP_INHERIT_FP_CONTROL
                         Enables  (true) or disables (false) the
                         copying of the  floating-point  control
                         settings  of  the  master 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*  run-time  library
                         execution  mode.  The  values  for this
                         variable  are  serial,  turnaround,  or
                         throughput.

        Default:throughput

       KMP_MONITOR_STACKSIZE
                         Sets  the  number  of bytes to allocate
                         for the monitor thread, which  is  used
                         for  book-keeping during program execu-
                         tion.

       Use the optional suffixes to specify byte
                         units:  B  (bytes),  K  (Kilobytes),  M
                         (Megabytes),  G (Gigabytes), or T (Ter-
                         abytes) to specify the  units.  If  you
                         specify  a  value without a suffix, the
                         byte unit is assumed  to  be  K  (Kilo-
                         bytes).

        Default: max (32k, system minimum

       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  (Ter-
                         abytes)  to  specify  the units. If you
                         specify a value without a  suffix,  the
                         byte  unit  is  assumed  to be K (Kilo-
                         bytes).

       This variable does not affect the native
                         operating system threads created by the
                         user  program  nor the thread executing
                         the sequential part of an OpenMP*  pro-
                         gram or parallel programs created using
                         the option Qparallel (Windows) or qpar-
                         allel (Linux and OS X).

       KMP_STACKSIZE overrides
                         GOMP_STACKSIZE,     which     overrides
                         OMP_STACKSIZE.

        Default (IA-32 architecture): 2m

        Default (Intel(R) 64 architecture):
                         4m

        Default (Intel(R) MIC
                         architecture):4M (on supported OSes)

       KMP_VERSION       Enables (true) or disables (false)  the
                         printing  of  OpenMP*  run-time library
                         version information during program exe-
                         cution.

        Default:false

       KMP_WARNINGS      Enables (true) or disables (false) dis-
                         playing  warnings  from   the   OpenMP*
                         run-time  library during program execu-
                         tion.

        Default:true

        Intel(R) Graphics Technology Environment Variables
                         (GFX_)

                         then the code is executed on  the  tar-
                         get.  Otherwise,  back-up  execution on
                         the  host  depends  on  the  value   of
                         GFX_CPU_BACKUP.

       To prevent execution from occurring on the host, which
                         causes the application to fail when the
                         target   is    not    available,    set
                         GFX_CPU_BACKUP to 0.

       To  execute on the host when the target is not available,
       set
                         GFX_CPU_BACKUP  to  1. By default, this
                         variable is set to 1, so  the  code  is
                         executed on the host.

        Default: 1

       GFX_MAX_THREAD_COUNT
                         Controls  the  maximum number of target
                         threads  to  parallelize   loop   nests
                         offloaded  to  the  graphics cores. Use
                         this variable to override  the  default
                         maximum value.

       Two values have special meaning:

                         · -  1  (the default): The runtime cre-
                           ates one  thread  for  each  parallel
                           loop  nest  iteration.  Loops  can be
                           vectorized, and  one  iteration  exe-
                           cuted by a thread may include several
                           original loop iterations.

                         · 0:   The   threadcount   is   N*hard-
                           ware_thread_count, where N is:

                           ·   4 for one-dimensional loop nests.

                           ·  8 for loop nests of  two  or  more
                             dimensions.
                         Try  using  this value when tuning your
                         program for performance.

       Scheduling many threads (e.g. 512) helps
                         hide the latency  of  some  operations,
                         but  a  large  number  of  threads  can
                         increase the cost of offload  or  nega-
                         tively  affect performance. By default,
                         the  runtime  automatically  determines
                         the maximum thread count.

                         (usually two seconds). The task appears
                         to hang and abnormally terminate  after
                         another  timeout, defined by this vari-
                         able. To  enable  longer  execution  of
                         your offload tasks, disable recovery on
                         timeout in the system  registry  (refer
                         to    Microsoft*    documentation   for
                         instructions) and set GFX_OFFLOAD_TIME-
                         OUT  to  a  higher value, if 60 seconds
                         are insufficient.

        Default:         60 seconds.

       GFX_LOG_OFFLOAD   Enables  or  disables  logging  of  the
                         offload  process by setting this to the
                         desirable logging level, from 1  to  3,
                         where  3  has  the  greatest  amount of
                         detail.

       To see the number of available hardware threads, set this
                         environment variable to 1.

       To monitor the real thread count, set this environment
                         variable to 2.

       To monitor the real thread count as well as  distribution
       of
                         the parallel  loop  nest ’s  iteration
                         space, set this environment variable to
                         3.

       To disable logging,  set  this  environment  variable  to
       either
                         an empty string or 0.

       NOTE: Enabling logging significantly increases the  over-
       head of offload, so it is recommended only for debugging.

       GFX_SHOW_TIME     Enables  or  disables  printing  timing
                         information at the end of execution.

       To disable timer printing, set
                         GFX_SHOW_TIME to either an empty string
                         or 0.


       GFX_THREAD_GROUP_WIDTH
                         Sets  the  width  of  a   thread
                         group.

       GFX_THREAD_GROUP_HEIGHT
                         Sets  the  height  of  a  thread

       This variable overrides the function
                         _GFX_set_thread_space_config.

       GFX_THREAD_SPACE_HEIGHT
                         Sets the height  of  the  thread
                         space, in threads.

       When this variable is set to
                         0,  or  not  set, an appropriate
                         value  is  calculated  automati-
                         cally.

       This variable overrides the function
                         _GFX_set_thread_space_config.

        Intel(R) Many Integrated Core
                         (Intel(R) MIC) Environment Vari-
                         ables

       MIC_ENV_PREFIX    Controls  environment  variables
                         passed to the target.

       By  default,  all environment variables set on the
       host are
                         passed  to  the  target. Setting
                         MIC_ENV_PREFIX passes only envi-
                         ronment  variables  that  have a
                         prefix  of  the  value  of  this
                         variable.   For example, setting
                         MIC_ENV_PREFIX=ABC  passes  only
                         environment  variables that have
                         a prefix of ABC.

       NOTE: Because the MIC_LD_LIBRARY_PATH variable  is
       not  stripped and passed to the target, you cannot
       use   MIC_ENV_PREFIX=   MIC    to    change    the
       LD_LIBRARY_PATH on the target.

       To change LD_LIBRARY_PATH on the target:

       1)

           Set MIC_ENV_PREFIX to any prefix other than
            MIC.

       2)

           Create  an  additional  pre-fixed  environment
           variable on the host set to the desired  value
           for LD_LIBRARY_PATH for the target.

       For  example,  setting these two environment vari-
                         not  passed  to  the target. See
                         MIC_ENV_PREFIX for special  han-
                         dling  of  the value on the tar-
                         get.

       Use               LD_LIBRARY_PATH for the location
                         of  host-specific shared objects
                         on  a  host  system,   including
                         those   for  the  Intel(R)  Xeon
                         Phi(TM) coprocessor  (code  name
                         Knights Landing).

       MIC_PROXY_IO      Enables  (1) or disables (0) the
                         proxy of stderr and stdout,  and
                         specifies  whether  the  process
                         wants I/O proxy support  between
                         the host and target.

        Default:1

         Example:MIC_PROXY_IO=0

       MIC_SEP_MONITOR   Enables  (1) or disables (0) SEP
                         at offload regions.

        Default:0

         Example:MIC_SEP_MONITOR=1

       MIC_STACKSIZE     Specifies the stack size of  the
                         main  thread  for  the  offload.
                         This  value  is  typically  much
                         larger  than  the stack size for
                         individual  threads.  It  corre-
                         sponds  to  what  you  would set
                         with ulimit -s (BASH  shell)  or
                         limit stacksize (C shell) if you
                         were running natively on  either
                         the target or the host.

       Set this variable to
                         integerB|K|M|G|T, where:

                         · B = bytes

                         · K = kilobytes

                         · M = megabytes

                         · G = gigabytes

                         · T = terabytes
                         integerB|K|M|G|T, where:

                         · B = Bytes

                         · K = Kilobytes

                         · M = Megabytes

                         · G = Gigabytes

                         · T = Terabytes

         Example:MIC_USE_2MB_BUFFERS=64K

       OFFLOAD_DEVICES   Restricts the offload process to
                         use only the coprocessors speci-
                         fied as the value of  the  vari-
                         able.

       Set  this  variable  to  a comma-separated list of
       target device
                         numbers  in the range 0 to (num-
                         ber_of_devices_in_the_system
                         -1), where 0 is the first copro-
                         cessor in the system, and  (num-
                         ber_of_devices_in_the_system -1)
                         is the last coprocessor  in  the
                         system.

       Coprocessors available for offloading are numbered
                         logically.      The     function
                         _Offload_number_of_devices()
                         returns  the number of available
                         coprocessors.        Coprocessor
                         indices that you use in the tar-
                         get  specifier  of  the  offload
                         pragmas  are mapped to coproces-
                         sors        specified         in
                         OFFLOAD_DEVICES.

        Default: The offload process uses
                         all devices.

         Example:OFFLOAD_DEVICES = 1,2

       On  a  system  with  more  than  two  coprocessors
       installed, this
                         setting  enables the application
                         to use only coprocessors  1  and
                         2. Offloads to coprocessors 0 or
                         1 are performed  on  the  second
                         and third physical coprocessors.
                         OFFLOAD_DEVICES=none)    impacts
                         the execution of offloaded  code
                         within your program as follows:

                         · When you use optional offload-
                           ing, the code executes on  the
                           host CPU.

                         · When    you    use   mandatory
                           offloading, the program termi-
                           nates  with  an offload error,
                           reporting that a device is not
                           available,  when  it reaches a
                           point in the  execution  where
                           the  coprocessor requires ini-
                           tialization for offloading.

       You can specify optional and mandatory  offloading
       using the
                         optional and  mandatory  clauses
                         in either of the following:

                         · The  compiler  option qoffload
                           (Linux) or Qoffload (Windows)

                         · The offload pragma

       OFFLOAD_NODES     Defines a subset  of  a  cluster
                         (group of servers or nodes) that
                         is available for offloading from
                         the host system. When offloading
                         within a cluster, this  environ-
                         ment  variable  must  be  set to
                         specify      the       available
                         offload-able nodes.

       The   value  of  the  environment  variable  is  a
       comma-separated
                         list  of  machine  specifiers. A
                         machine specifier  is  either  a
                         machine  name  or an IP address.
                         The  machine  specifier  may  be
                         optionally  followed by a speci-
                         fication of the  node  type  and
                         fabric  type in square brackets.
                         The default node  type  is  cur-
                         rently x200 and the default fab-
                         ric type is OFI. More  node  and
                         fabric types may be supported in
                         the future.

       The  offloadable  machines  in  OFFLOAD_NODES  are
                         if doing offload within a  clus-
                         ter.

         Example:
                         export OFFLOAD_NODES="machine1,machine2,10.2.100.50"

         Example:                                  export
       OFFLOAD_NODES="machine3[x200,OFI]"

         Example: In the following,
                         machine2 and 10.2.100.50 will be
                         used as processor  0  and  1  in
                         target  specified in the offload
                         pragma.

       export
       OFFLOAD_NODES="machine1,machine2,10.2.100.50"
       export OFFLOAD_DEVICES=1,2


       OFFLOAD_INIT      Specifies a hint to the  offload
                         runtime  indicating when to ini-
                         tialize targets.

       Possible values:

       · on_start: All available  coprocessors  are  ini-
         tialized before entering main.

       · on_offload:  The  target  is initialized immedi-
         ately before the first offload to  it.  Initial-
         ization  is done only on the target that handles
         the offload.

       · on_offload_all: All available targets  are  ini-
         tialized immediately before the first offload in
         an application.

        Default:on_offload_all

         Example:OFFLOAD_INIT=on_start

       OFFLOAD_REPORT    Controls printing offload execu-
                         tion  time,  in seconds, and the
                         amount of data  transferred,  in
                         bytes. This environment variable
                         is  equivalent  to   using   the
                         __Offload_report API.

       Possible values:

       · 1:  Prints the offload computation time, in sec-

       See also          _Offload_report.

        Profile Guided Optimization
                         (PGO_) Environment Variables

       INTEL_PROF_DUMP_CUMULATIVE
                         When   using   interval  profile
                         dumping      (initiated       by
                         INTEL_PROF_DUMP_INTERVAL  or the
                         function      _PGOPTI_Set_Inter-
                         val_Prof_Dump) during the execu-
                         tion  of  an  instrumented  user
                         application,  allows creation of
                         a single information instead  of
                         multiple    instrumented    user
                         application creates a new

       Setting this environment variable is
                         useful for applications that  do
                         not terminate or those that ter-
                         minate  abnormally  (bypass  the
                         normal exit code).

       INTEL_PROF_DUMP_INTERVAL
                         Initiates interval profile dump-
                         ing  in  an  instrumented   user
                         application.   This  environment
                         variable may be used to initiate
                         Interval  Profile  Dumping in an
                         instrumented application.

       INTEL_PROF_DYN_PREFIX
                         Specifies the prefix to be  used
                         for  the  other  files dumped by
                         other PGO  runs.  Executing  the
                         instrumented  application gener-
                         ates a .dyn filename as follows:
                         <prefix>_<timestamp>_<pid>.dyn,
                         where <prefix> is the identifier
                         that you have specified.

       NOTE:  The  value  specified  in  this environment
       variable must not contain < > : " /  | ? * charac-
       ters.  The  default  naming  scheme  is used if an
       invalid prefix is specified.

       PROF_DIR          Specifies  the  directory  where
                         profiling   files   (files  with
                         extensions is to store  the  the
                         file  containing  the first exe-
                         cuted  instrumented  routine  in

       PROF_DPI          Name for the

        Default:         pgopti.dpi

       PROF_DUMP_INTERVAL
                         Deprecated;                  use
                         INTEL_PROF_DUMP_INTERVAL
                         instead.

       PROF_NO_CLOBBER   Alters  the feedback compilation
                         phase slightly. By default, dur-
                         ing   the  feedback  compilation
                         phase, the compiler merges  data
                         from   all  dynamic  information
                         files   and   creates   a    new
                         pgopti.dpi     file    if    the
                         pgopti.dpi file.

       When this variable is set, the compiler
                         does not overwrite the  existing
                         pgopti.dpi  file.  Instead,  the
                         compiler issues a  warning.  You
                         must  remove the pgopti.dpi file
                         if you want  to  use  additional
                         dynamic information files.



Compiler Options for Intel(R) C++ Compiler

       Standard   Edition   for   Embedded  Systems  with
       Bi-Endian Technology

       The Intel(R) C++  Compiler  Standard  Edition  for
       Embedded  Systems  with  Bi-Endian  Technology  is
       based on the standard Intel(R) C++  Compiler  16.0
       for  Linux* systems. In general, the functionality
       offered by this compiler matches that of the stan-
       dard Intel(R) C++ Compiler for Linux systems. How-
       ever some features of the  standard  compiler  are
       not  supported. For a list of the unsupported fea-
       tures, see the Intel(R) C++ Compiler Standard Edi-
       tion  for Embedded Systems with Bi-Endian Technol-
       ogy user documentation.

   New Options
       The following new options are available for embed-
       ded systems with bi-endian technology.

       Option             Description

       -mx32             Tells  the  compiler to set int,
                         long and pointer type data to 32
                         bits  while  generating code for

       -[no]-normal-pe-files
                         Enables/disables   the  "normal"
                         prolog/epilog  processing   that
                         looks   into  the  include  file
                         directories for __intel_prolog.h
                         and    __intel_epilog.h   files.
                         There is no replacement  option.

       -pe-dir-rule      Allows  prolog  and epilog files
                         to be selected based on a direc-
                         tory  search. Consider using the
                         -pe-(i|u)dir-rule        options
                         instead.

       -Qoption,cpp, --separate_biendian_types
                         Enables  extended  bi-endian C++
                         support  mode.  Use  the   -qen-
                         able-biendian-extended-cxx
                         option instead.


Alphabetical List of Compiler Options for

       Intel(R) C++ Compiler Standard Edition for  Embed-
       ded Systems with Bi-Endian Technology

       -[no-]add-response-file-dependencies

              This  option  applies only to the bi-endian
              C++
                     compiler.   Includes  response files
                     in dependency generation output.

              Arguments:

              None

              Default:

              OFF

              Description:

              This option specifies that  response  files
              and  configuration files containing command
              line options  are  included  in  dependency
              output  when dependencies are requested. By
              default, these files are  not  included  in
              dependency output.

              This option is effective only when:

              · dependency information is being generated

              This option enables  bi-endian  compilation
              mode  and  specifies  that  the compilation
              should assume big-endian byte order as  the
              default.  Bi-endian  compilation  mode also
              means that the byte_order  pragma  and  the
              endian  type  attributes are enabled.  How-
              ever,  if  you  have  used  the  byte_order
              pragma and/or type byte order attributes in
              your code,  it  overrides  the  byte  order
              specified in the command line.

              For  example,  consider  a  C program file,
              test.c, where you have not used  byte_order
              pragma or the type byte order attributes in
              your code. To compile, enter the  following
              at the command prompt:

              icc -c -big-endian test.c


              The  above command line entry causes test.c
              to  be  compiled  in  bi-endian  mode  with
              big-endian byte order.

       -debug[keyword]

              This  option  applies only to the bi-endian
              C++
                     compiler.   Enables or disables gen-
                     eration of debugging information.

              Arguments:

              keyword           Is   a   value   denoting
                                enhanced  debugging. Pos-
                                sible value:

                                biendian       Produces
                                               enhanced
                                               debug
                                               informa-
                                               tion   for
                                               big endian
                                               data.

              Default:

              OFF               No  additional  debugging
                                information  is generated
                                for big-endian data.

              C++
                     compiler.   Enables  a biendian-spe-
                     cific message group.

              Description:

              This option  enables  the  whole  group  of
              bi-endian-specific   diagnostics   -  1697,
              2324, 2325, 2334, 2710,  2951  -  that  are
              disabled  by default. See Warning Reference
              for more details.

       -dynamic-loader-data-init

              This option applies only to  the  bi-endian
              C++
                     compiler.   Specifies  the   dynamic
                     loader   initialization   mode   for
                     big-endian data when directly  using
                     bepostld,  the  bi-endian  post  lnk
                     tool.

              Description:

              This option is supported by  the  Bi-endian
              Post   Link  Tool,  bepostld,  when  it  is
              invoked directly on the command line.  This
              option  specifies  the  dynamic loader ini-
              tialization mode for big-endian data.

              This option is disabled and ignored at com-
              pile  time  by  the compiler. No warning or
              error is generated.

       -dynamic-runtime-data-init

              This option applies only to  the  bi-endian
              C++
                     compiler.   Specifies  the   dynamic
                     runtime   initialization   mode  for
                     big-endian data when directly  using
                     bepostld,  the  bi-endian  post link
                     tool.

              Description:

              This option is supported by  the  Bi-endian
              Post   Link  Tool,  bepostld,  when  it  is
              invoked directly on the command line.  This
              option  specifies  the dynamic runtime ini-
              tialization mode for big-endian data.

              string            Is   a  character  string
                                delimited    by    double
                                quotes.

              Default:

              ""                An  empty  string  is the
                                default.

              Description:

              This  option  specifies  a  string  to   be
              prepended to external C symbols (similar to
              #pragma extern_prefix). The default is  the
              empty string (""). This option applies to C
              compilations only.

       -fdefer-pop

       -fno-defer-pop

              This option applies only to  the  bi-endian
              C++
                     compiler.    Prohibits   or   allows
                     deferred   clearance  of  the  stack
                     arguments.

              Arguments:

              None

              Default:

              -fdefer-pop       Deferred   clearance   of
                                stack     arguments    is
                                allowed, by default.


              Description:

              This option prohibits  or  allows  deferred
              clearance of the stack arguments.

              Specify  fno-defer-pop to prohibit deferred
              clearance of the stack arguments.

       -little-endian

              This option applies only to  the  bi-endian
              C++
                     compiler.  Enables bi-endian  compi-
                     lation  mode  and specifies that the

              your code,  it  overrides  the  byte  order
              specified in the command line.

              For  example,  consider  a  C program file,
              test.c, where you have not used  byte_order
              pragma or the type byte order attributes in
              your code. To compile, enter the  following
              at the command prompt:

              icc -c -little-endian test.c


              The above line causes test.c to be compiled
              in bi-endian mode with  little-endian  byte
              order.

       -[no-]little-endian-defaultlibs

              This  option  applies only to the bi-endian
              C++
                     compiler.  Instructs the compiler to
                     treat  default  libraries  as   lit-
                     tle-endian during type checking.

              Description:

              When  an  application  is compiled with the
              type  checking  mechanism  enabled   (using
              -symcheck   option),  the  compiler  checks
              global variables and routines  for  consis-
              tency.

              In  order  to  perform  type  checking  for
              global variables imported from  a  library,
              the  library  should  be  compiled with the
              -symcheck option as well.  However, this is
              not  possible for all libraries.  For exam-
              ple, the -symcheck option  is  unlikely  to
              recompile system libraries.

              In  such cases, the -little-endian-default-
              libs option instructs the compiler to treat
              all  libraries  implicitly  linked  to  the
              application as  little-endian  during  type
              checking.

              NOTE:  Libraries explicitly provided by you
              will not be recognized as little-endian. If
              incompatibilities   are   found,  they  are
              reported in the usual way by the  Bi-Endian
              Post Link Tool.

                                It  can  be   a   regular
                                expression  or start with
                                -l   prefix.   For   more
                                details, see the Descrip-
                                tion section below.

              Description:

              This option has the  same  effect  as  lit-
              tle-endian-defaultlibs   but  the  list  of
              libraries is  explicitly  provided  by  the
              option.

              The  library  name  can be either a regular
              expression or start with -l prefix. In  the
              first  case  when the library name is given
              by a regular expression,  it  should  match
              the  full library name including the direc-
              tory path where the library is located. The
              syntax   used  in  the  regular  expression
              should follow the POSIX  standard.  In  the
              second  case, the name should be given in a
              short form without the "lib" prefix and the
              ".so.a"    suffix.   For   example,   -lit-
              tle-endian-libs=-lmy  tells   compiler   to
              interpret libmy.a/libmy.so as little-endian
              during type checking.  Libraries  specified
              by  this option are searched using the same
              rules as other regular libraries.

       -multiline-strings

       -no-multiline-strings

              This option applies only to  the  bi-endian
              C++
                     compiler.  Enables or  disables  new
                     line characters in multi-line string
                     literals.

              Default:

              -no-multiline-strings
                                You cannot  compile  code
                                with  new-line characters
                                within string literals.

              Description:

              The -multiline-strings option allows you to
              compile  code  without  new-line characters
              within string literals. For  example,  con-
              ^ foo.c(2): error: expected a ";" multiline
              string to a var."; ^ foo.c(2): error: miss-
              ing  closing  quote  multiline  string to a
              var.";  ^  compilation  aborted  for  foo.c
              (code 2)


              NOTE:  When  you use the -multiline-strings
              option and some  of  your  strings  contain
              new-line  characters,  you will get warning
              number 1345. You can disable  this  warning
              with -wd1345. You can also use this warning
              to locate new-line  characters  and  remove
              them, if required.

       -mx32

              This  option  applies only to the bi-endian
              C++
                     compiler.  Tells the compiler to set
                     int, long and pointer type  data  to
                     32  bits  while  generating code for
                     x86-64 architecture.

              Architecture Restrictions: Not available on
              Intel(R) 64 architecture targeting Intel(R)
                     MIC Architecture

              Arguments:

              None

              Default:

              OFF               x32  psABI  code  is  not
                                generated

              Description:

              This  option enables x32 psABI code genera-
              tion. It sets  integer,  long  and  pointer
              type  data  to  32  bits,  turning  on  x32
              [ILP32] programming mode on  x86-64  archi-
              tectures.  This  option sets the _ILP32 and
              __ILP32__ predefined macros.

              This option is compatible with GCC's  -mx32
              option.

       -normal-pe-files

       -[no-]normal-pe-files
              This  option  enables or disables the "nor-
              mal" prolog/epilog processing, which  looks
              into   the  include  file  directories  for
              __intel_prolog.h    and    __intel_epilog.h
              files.

              By default, the "normal" prolog/epilog pro-
              cessing is disabled and the location of the
              prolog/epilog files is determined solely by
              the   -pe-dir-rule,   -pe-udir-rule,    and
              -pe-idir-rule options.

       -param-byte-order=<val>

              This  option  applies only to the bi-endian
              C++
                     compiler.   Specifies  the parameter
                     passing mode.

              Arguments:

              val               Specifies  the  order  of
                                passing   parameters,  it
                                can take one of the  fol-
                                lowing values:

                                legacy         Parameters
                                               are passed
                                               in     the
                                               declared
                                               byte order
                                               (compati-
                                               bility
                                               mode).

                                little-endian  Parameters
                                               are passed
                                               in     the
                                               lit-
                                               tle-endian
                                               form (rec-
                                               ommended).

              Default:

              The default value is legacy.

              Description:

              This option specifies the parameter passing
              mode. The new, little-endian mode is recom-
              mended  for  porting  new applications. The
              C++
                     compiler.  Allows prolog and  epilog
                     files  to  be  selected  based  on a
                     directory search. This is  a  depre-
                     cated  option;  consider  using  the
                     -pe-(i|u)dir-rule instead.

              Arguments:

              regular expression
                                Is a  regular  expression
                                using POSIX Extended Reg-
                                ular Expression syntax. A
                                specified prolog and epi-
                                log file will be  applied
                                to both header and source
                                files  in  the  directory
                                matching    the   regular
                                expression.

              prolog            file Is  the  name  of  a
                                prolog file.

              epilog            file  Is  the  name of an
                                epilog file.

              Description:

              This option allows prolog and epilog  files
              to be selected based on a directory search.
              More than one -pe-dir-rule  option  can  be
              specified  on the command line. If multiple
              -pe-dir-rule options  are  specified,  they
              are  processed  in the order received until
              the first match.

              This is a deprecated option; consider using
              the -pe-(i|u)dir-rule instead.

       -pe-file-prefix=<prefix>

              This  option  applies only to the bi-endian
              C++
                     compiler.   Adds  a  prefix  to pro-
                     log/epilog file names  specified  by
                     -pe-(i|u)dir-rule option.

              Arguments:

              <prefix>          User-specified     prefix
                                added  to  the  names  of
                                prolog  and  epilog files

              $ icc -pe-idir-rule="/usr/include /tmp/pro-
              log.h /tmp/epilog.h"

              you can specify /tmp in the -pe-file-prefix
              option to do the same:

              $          icc         -pe-file-prefix=/tmp
              -pe-idir-rule="/usr/include  prolog.h  epi-
              log.h


       -[no-]pe-file-primary

              This  option  applies only to the bi-endian
              C++
                     compiler.  Enables/disables the pro-
                     log-epilog mechanism for  bracketing
                     source files.

              Default:

              OFF               The   -no-pe-file-primary
                                option is the default.

              Description:

              This option enables or  disables  the  pro-
              log-epilog  mechanism for bracketing source
              files.

              By default the bi-endian compiler  brackets
              system     header    files    (like#include
              <sys_h.h>) using prolog and  epilog  files.
              You  can use the -pe-file-primary option to
              bracket source files (*.c / *.cpp).

              However, the source files are handled in  a
              way  similar  to  user  headers  files; for
              example:#include “my_h.h”. Therefore,  to
              bracket  the source files, you must use the
              -pe-file-primary  option  along  with   the
              -pe-udir-rule=  option at the command line.

       -pe-idir-rule=<regular
              expression> <prolog file> <epilog file>

              This option applies only to  the  bi-endian
              C++
                     compiler.  Specifies a set of system
                     and  user  directories to be associ-
                     ated with a prolog and epilog  file.

                                prolog file.

              epilog            file Is the  name  of  an
                                epilog file.

              Description:

              This  option allows prolog and epilog files
              to be selected based on a directory search.

              More  than  one -pe-idir-rule option can be
              specified on the command line.  If multiple
              -pe-idir-rule  options  are specified, they
              are processed in the order  received  until
              the first match.

              The  -pe-idir-rule  option is processed for
              headers available  through  system  include
              paths.  If  none of the regular expressions
              defined by -pe-idir-rule matches  a  direc-
              tory  where  a  header file is located, the
              __intel_prolog.h  and   __intel_epilog.hlo-
              cated  in  the compiler's include directory
              are used.

              You can also set an environment variable in
              a configuration file, assigned with a value
              specifying the  directory  where  the  pro-
              log/epilog  files are located. For example,
              consider the environment  variable  MY_PATH
              with values specifying the path to the pro-
              log and epilog files. You can use the envi-
              ronment variable, MY_PATH as follows:

              -pe-idir-rule="%$(MY_PATH)/
              %$(MY_PATH)/prolog.h %$(MY_PATH)/epilog.h"


              NOTE: The makefiles based on the deprecated
              -pe-dir-rule   option   or  the  -[no-]nor-
              mal-pe-files option may remain unchanged.

       -pe-udir-rule=<regular
              expression> <prolog file> <epilog file>

              This option applies only to  the  bi-endian
              C++
                     compiler.  Specifies a set  of  user
                     directories  to be associated with a
                     prolog and epilog file.

              Arguments:

              epilog            file  Is  the  name of an
                                epilog file.

              Description:

              This option allows prolog and epilog  files
              to be selected based on a directory search.

              More than one -pe-udir-rule option  can  be
              specified on the command line.  If multiple
              -pe-udir-rule options are  specified,  they
              are  processed  in the order received until
              the first match.

              The -pe-udir-rule option is  processed  for
              headers   available  through  user  include
              paths. If none of the  regular  expressions
              defined  by  -pe-udir-rule matches a direc-
              tory where a header file is  located,  then
              the pe-idir-rule option is processed.

              You can also set an environment variable in
              a configuration file, assigned with a value
              specifying  the  directory  where  the pro-
              log/epilog files are located. For  example,
              consider  the  environment variable MY_PATH
              with values specifying the path to the pro-
              log and epilog files. You can use the envi-
              ronment variable, MY_PATH as follows:

              -pe-udir-rule="%$(MY_PATH)/
              %$(MY_PATH)/prolog.h %$(MY_PATH)/epilog.h"


       -platform=default|<target
              platform>|<embedded target platform>

              This   option  applies  only for cross-com-
                     piling compilers like bi-endian  C++
                     compiler  and Intel(R) System Studio
                     C++  compiler.Specifies  the  target
                     platform for cross compilation.

              Arguments:

              default           Disables       previously
                                defined -platform, --sys-
                                root,   and   -gnu-prefix
                                values  and  forces  com-
                                piler  to  generate  code
                                for the  default  target,
                                               taVista*
                                               Linux*  OS
                                               target.

                                netbsd51       Specifies
                                               the
                                               NetBSD* OS
                                               target.

                                wrl30          Specifies
                                               the   Wind
                                               River*
                                               Linux*  OS
                                               target.

              embedded target   platform Can be  any  one
                                of the following, if sup-
                                ported:

                                android        Specifies
                                               the
                                               Android*
                                               target.

                                celpr28        Specifies
                                               the     CE
                                               Linux*  OS
                                               target.

                                wrl43          Specifies
                                               the   Wind
                                               River*
                                               Linux*  OS
                                               v4.3  tar-
                                               get.

                                wrl50          Specifies
                                               the   Wind
                                               River*
                                               Linux*  OS
                                               v5.0  tar-
                                               get.

                                yl12           Specifies
                                               the Yocto*
                                               Project OS
                                               v1.2  tar-
                                               get.

                                yl13           Specifies
                                               the Yocto*
                                               Project OS

              --sysroot  options, and forces the compiler
              to generate code  for  the  default  target
              platform.

       -promote-varargs-to-64bit

              This  option  applies only to the bi-endian
              C++
                     compiler.  Promotes big-endian argu-
                     ments passed to varargs functions to
                     64-bit.  This  option  is only valid
                     for 64-bit architecture.

              Description:

              This option promotes  big-endian  arguments
              passed  to varargs functions to 64-bit.  It
              forces the compiler to  promote  non-64-bit
              big-endian arguments passed to vararg/vari-
              adic functions to 64-bit. For example,  you
              can  use  this  option  to  promote  32-bit
              big-endian   arguments   passed   to   void
              my_printf(const  char*,  ...)  function, to
              64-bit.

       -qenable-biendian-extended-cxx

       -qno-enable-biendian-extended-cxx

              This option applies only to  the  bi-endian
              C++
                     compiler.  Enables extended C++ sup-
                     port  mode  for template initializa-
                     tion in the bi-endian compiler.

              Arguments:

              None

              Default:

              -qno-enable-biendian-extended-cxx
                                Extended C++ mode support
                                is disabled

              Description:

              By default, the bi-endian compiler uses the
              simple C++ support mode for  template  ini-
              tialization,  which  works  well for C pro-
              grams with limited use of C++ features.  In
              the  simple C++ support mode, byte order is
              To disable the extended C++  mode  support,
              use  the  -qno-enable-biendian-extended-cxx
              option.

              The  -Qoption,cpp,--separate_biendian_types
              option  that  was used previously to enable
              extended C++ mode, is deprecated.

              Alternate Options:

              -Qoption,cpp,--separate_biendian_types   is
              deprecated

       -[no-]resolve-byte-order-mismatch

              This  option  applies only to the bi-endian
              C++
                     compiler.  Enables automatic adjust-
                     ment of  the  pointed-to  type  byte
                     order.

              Arguments:

              None

              Default:

              OFF

              Description:

              This option enables automatic adjustment of
              the pointed-to type byte order in the  fol-
              lowing cases:

              · The  pointed-to value is a local variable
                of an integer or pointer data type.

              · The byte order of  the  variable  or  its
                type  is not set explicitly with the byte
                order  attribute   (__attribute__((bigen-
                dian)) or __attribute__((littleendian))).

              · Changing byte order of  the  variable  in
                its  definition will not cause byte order
                mismatches with pointed-to  type  in  any
                place where the variable is used.

              NOTE:  If a variable is used as a parameter
              in a method call, its byte order is counted
              according to the method declaration.

              Default:

              OFF

              Description:

              This  option enables bi-endian extended C++
              mode. This option is deprecated. Use  -qen-
              able-extended-mode-cxx option instead.

       -size-llp64

              This  option  applies only to the bi-endian
              C++
                     compiler.  Enables LLP64 compilation
                     mode.

              Description:

              This option enables the  LLP64  compilation
              mode. In this mode the compiler uses 64-bit
              pointers,  but  long  data   types   remain
              32-bit.   The   long   long,   size_t,  and
              ptrdiff_tdata types are 64-bit.

              The -size-llp64 sets the  following  prede-
              fined macros:

              __LONG_MAX__=2147483647L  __LLP64__  _LLP64
              __PTRDIFF_TYPE__="long                long"
              __SIZE_TYPE__="unsigned long long"


              NOTE: Objects compiled with this option are
              not compatible with objects compiled  with-
              out this option.

       -static-data-init

              This  option  applies only to the bi-endian
              C++
                     compiler.  Specifies static initial-
                     ization mode for big-endian data. By
                     default, this option is disabled and
                     silently ignored at compile time.

              Default:

              OFF

              Description:

                     of pointer and  reference  type  are
                     byte swapped.

              Default:

              -swap-pointers    Objects  of  pointer  and
                                reference type  are  byte
                                swapped by default.

              Description:

              This  option  specifies  whether objects of
              pointer  and  reference   type   are   byte
              swapped. This option is particularly impor-
              tant  when  mixing   code   (for   example,
              big-endian  code  calling  a  little-endian
              library).  The  default  setting  is   that
              objects  of  pointer and reference type are
              byte swapped.

              You can improve application performance  by
              specifying the -no-swap-pointers option. If
              a pointer is declared as big-endian, it  is
              assumed  to  be big-endian. For example, in
              the  following  statements,  x  and  y  are
              big-endian but x1 and y1 are little-endian.

              #pragma byte_order big-endian int x; int  *
              y; #pragma byte_order little-endian int x1;
              int * y1;


              If you specify -no-swap-pointerswhile  com-
              piling,  the pointers are processed differ-
              ently. Both y and y1are assumed to be  lit-
              tle-endian,  even  though  y is declared in
              the big-endian context.


              Optimization Notice


              = = = = = = = = = =

              Intel's compilers may or may  not  optimize
              to  the same degree for non-Intel micropro-
              cessors  for  optimizations  that  are  not
              unique   to  Intel  microprocessors.  These
              optimizations include SSE2, SSE3, and SSSE3
              instruction  sets  and other optimizations.
              Intel does not guarantee the  availability,
              functionality,   or  effectiveness  of  any

       -symcheck

              This option applies only to  the  bi-endian
              C++
                     compiler.    Enables   checking   of
                     global symbol types.

              Default:

              OFF

              Description:

              This  option  activates  type  checking  of
              global variables  and  routines.  When  you
              specify  this  option for the compile step,
              the compiler generates type information for
              every   public   data  object  and  routine
              defined or referenced  in  the  compilation
              units.

              If  you  specify  this  option for the link
              step, the compiler  invokes  the  bi-endian
              post  link  tool for checking the type con-
              sistency of public objects and routines  in
              the output file. The post link tool outputs
              descriptive messages for any incompatibili-
              ties it detects.

       -use-decl-byte-order

              This  option  applies only to the bi-endian
              C++
                     compiler.   Sets default behavior of
                     the  compiler  to  compile  function
                     definitions  with  byte order speci-
                     fied in the function declaration.

              Default:

              OFF

              Description:

              This option sets the  default  behavior  of
              the  compiler  to  compile function defini-
              tions with the byte order specified in  the
              function declaration.

              You  can  specify the behavior at the func-
              tion  level  with  the  use_decl_byte_order

       ware.intel.com/en-us/intel-software-technical-doc-
       umentation/.

   Product Website and Support
       To find technical support information, to register
       your product, or to contact Intel,  please  visit:
       https://software.intel.com/en-us/support/.

       At  this site, you will find comprehensive product
       information, including:

       · Links to each product, where you will find tech-
         nical information such as white papers, support,
         articles, and user forums

       · Links to news and events

   Release Notes
       For detailed information on  system  requirements,
       late  changes to the products, supported architec-
       tures, operating systems, and Integrated  Develop-
       ment  Environments (IDE) see the Release Notes for
       this product.

   Forums
       You can find  helpful  information  in  the  Intel
       Software  user  forums.  You can also submit ques-
       tions to the forums. To see the list of the avail-
       able      forums,      go     to     https://soft-
       ware.intel.com/en-us/forum/.


SEE ALSO

       icc(1), ld(1)

       Your compiler documentation has additional  refer-
       ence material on features of your compiler.


Legal Information

       No  license  (express  or  implied, by estoppel or
       otherwise) to any intellectual property rights  is
       granted by this document.

       Intel  disclaims  all  express  and  implied  war-
       ranties, including without limitation, the implied
       warranties  of merchantability, fitness for a par-
       ticular purpose, and non-infringement, as well  as
       any  warranty  arising from course of performance,
       course of dealing, or usage in trade.

       This document contains  information  on  products,
       services  and/or  processes  in  development.  All
       information provided here  is  subject  to  change

       Intel's compilers may or may not optimize  to  the
       same  degree  for  non-Intel  microprocessors  for
       optimizations that are not unique to Intel  micro-
       processors.   These  optimizations  include  SSE2,
       SSE3, and SSSE3 instruction sets and  other  opti-
       mizations. Intel does not guarantee the availabil-
       ity, functionality, or effectiveness of any  opti-
       mization  on  microprocessors  not manufactured by
       Intel. Microprocessor-dependent  optimizations  in
       this  product  are  intended  for  use  with Intel
       microprocessors. Certain  optimizations  not  spe-
       cific  to Intel microarchitecture are reserved for
       Intel microprocessors.  Please refer to the appli-
       cable  product  User and Reference Guides for more
       information  regarding  the  specific  instruction
       sets  covered  by  this  notice.   Notice revision
       #20110804

       Intel, the Intel logo,  Intel  Atom,  Intel  Core,
       Intel  Cilk,  Intel VTune, MMX, Pentium, Xeon, and
       Intel Xeon Phi are trademarks of Intel Corporation
       in the U.S. and/or other countries.

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

       (C) 2016, Intel Corporation.

       Portions  Copyright  (C)   2001,   Hewlett-Packard
       Development Company, L.P.



Copyright(C) 1996-2016         Intel Corporation                        ICC(1)

Man(1) output converted with man2html