Compiler Por ng Guide for ICC NextGen
Contents Compiler Por ng Guide for ICC NextGen ...... 1 Nomenclature ...... 2 Guiding Principles for ICC NextGen ...... 2 Major Changes in Compiler Defaults ...... 2 Important New Op ons ...... 3 Op ons to aid Intel Analyzers and other profiling tools. Use all of these to assist Analyzers...... 3 ICC NextGen OpenMP Op ons ...... 3 Compiler Versioning ...... 3 Data Parallel C++ Version String ...... 3 ICC NextGen Version String ...... 4 Important Compiler Op ons Mapping ...... 4 Pragma Support ...... 5 Predefined Macro Support ...... 6 Built-In Func ons ...... 6 Support for Pre-Compiled Header Files ...... 7 Changes in Diagnos cs Op ons and Diagnos c Message Numbering ...... 7 Linking, IPO and PGO changes ...... 9 Language Features ...... 9 Intrinsic Usage Model Change ...... 9 Example of LLVM Intrinsics Handling Differences ...... 10 Intrinsics Via Func on Defini on __a ribute__((target())) In the above example we used a compiler op on to target a specific instruc on set ( -mavx512f ). This can be used if just one instruc on set exists in the source file. O en, source files will contain mul ple instruc on sets represented in intrinsic data declara ons and intrinsic instruc ons. This is done to call specific func ons or code sec ons based on the run me processor discovery. Typically, these func ons or code sec ons are protected by #IFDEFs with specific target architectures and the user code does processor dispatch to these sec ons or func ons...... 13 Intel Proprietary Processsor Targe ng Pragmas and Func ons Support ...... 14 Legacy Intrinsics Promo on with Op on intrinsic-promote: ...... 14 Floa ng Point Reproducibility Controls ...... 15 Brutus or Bisec onal Op miza on Support ...... 15 Appendix I: ICC Classic Compiler Op ons Status ...... 15
March 6, 2020 1 Nomenclature • For simplicity and clarity, we will informally refer to the Intel® C++ Compiler Next Genera on framework as “ICC NextGen” and the classic or “tradi onal ICC” Intel® C++ Compiler as “ICC Classic” throughout this document. Guiding Principles for ICC NextGen • ICC Classic and ICC NextGen use the same name for many of the compiler drivers ( icc, icpc, icl ). In addi on to providing a core C++ compiler, ICC NextGen is the base compiler for the Intel® Data Parallel C++ compiler and its new driver, ‘dpcpp’. ICC NextGen is our newer “Next Genera on” compiler. Keep this in mind: ICC NextGen is not a drop-in replacement for ICC Classic. Although considerable effort is being made to make the transi on from ICC Classic to ICC NextGen as smooth and as effortless as possible, customers can expect that some effort may be required to port and tune exis ng applica ons from ICC Classic to ICC NextGen.
o For Data Parallel C++ applica ons: Our underlying compiler is ICC NextGen. The driver is named ‘dpcpp’.
o For standard C++ applica ons: ICC Classic (icc/icpc/icl drivers) will remain Intel’s recommended produc on compiler AND THE DEFAULT compiler un l ICC NextGen has performance and features superior to ICC Classic. In the future, when ICC NextGen func onality and performance equivalence or be er against ICC Classic is achieved, Intel may change the default for ICC to be ICC NextGen, instead of, ICC Classic. We have no set meline for this transi on as it is condi onal on reaching equivalence or be er than current ICC Classic technology. Going forward BOTH ICC Classic and ICC NextGen compilers will be provided in Intel Compiler packages. Compiler op ons will be used to select one or the other compilers. Major Changes in Compiler Defaults 1. C++ Users: The compiler driver name is s ll icc/icpc (Linux*) or icl (Windows*), but requires the – qnextgen (Linux*) or /Qnextgen (Windows*) op on to invoke the ICC NextGen compiler. Without the [-q|/Q]nextgen op on the ICC Classic compiler will be invoked. 2. DPC++ Users: Use the ‘dpcpp’ driver which invokes ICC NextGen with DPC++ extensions.
3. Default floa ng point model is -fp:precise –no-fma. 4. Macro __INTEL_LLVM_COMPILER is defined for ICC NextGen, instead of, the __INTEL_COMPILER macro used in ICC Classic. To see all defined values for the compiler, use -E -dM op ons which will either create a .ii file with this informa on or write the values to stderr. For example: for Data Parallel C++ dpcpp -E -dM ./hello.cpp more hello.ii for ICC NextGen the output will be sent to stderr icc -qnextgen -E -dM ./hello.cpp 5. No diagnos cs numbers are listed for remarks/warnings/notes. Every diagnos c is emi ed with the corresponding compiler op on to disable the same.
March 6, 2020 2 6. Compiler intrinsics will not be automa cally recognized without processor targe ng op ons, unlike the behavior in ICC Classic. If you use intrinsics, please read more on this intrinsic behavior change later in this document. Important New Op ons Op ons to aid Intel Analyzers and other profiling tools. Use all of these to assist Analyzers. • -gline-tables-only This op on is helpful for profiling tools. This op on generates line table debug informa on only. This allows symbolic back traces with inlining informa on, but does not include any informa on about variables, their loca ons, or types.
• -fdebug-info-for-profiling adds extra debug info for more accurate profile ICC NextGen OpenMP Op ons • -fiopenmp Compile and recognize OpenMP parallel and SIMD pragmas/direc ves and clauses and use the Intel OpenMP run me libraries.
• -fopenmp-targets=spir64 is needed when OpenMP 4.5/5.0 TARGET pragmas/direc ves are used.
• OpenMP 4.5/5.0 TARGET direc ves are only recognized by the ICC NextGen compiler that is included in the Intel® oneAPI HPC Toolkit. Use the two compiler op ons above together:
o icc -qnextgen -fiopenmp -fopenmp-targets=spir64
o icpc -qnextgen -fiopenmp -fopenmp-targets=spir64
Compiler Versioning
Data Parallel C++ Version String The Data Parallel C++ compiler version string is new. An example: dpcpp --version DPC++ Compiler 2021.1-betaXX (2019.8.x.1010) The format is:
VVVV.MINOR -[beta]XX (build string) where • VVVVV is the product VERSION in the format of year. • MINOR is a single-digit minor version number, star ng at “1” for ini al release and incremented as needed for minor releases. • [beta] may or may not appear. If the compiler is a Beta compiler you will see the string “beta”, else this will not be present for produc on compilers. • XX is the beta release • The (build string) can be decoded:
(YYYY.
March 6, 2020 3 where • YYYY is the year •
For example, (2019.8.x.1108) This compiler was built in 2019. The Clang front end is version 8. The PULL in this beta is “x”, but in a later compiler this will indicate the pull date or minor version. The exact date of the build is 2019 1108 in YYYY MMDD
Another example: If, hypothe cally, Clang 9 releases and we create a new version of the Intel compiler in March 2020, then the ICC NextGen version released in March 2020 would be versioned 2020.9.3.0. If there is a June 2020 release, the version will be 2020.9.6.0.
ICC NextGen Version String The ICC NextGen compiler version string is new. The format is: VVVV.MINOR [Beta]
An example: icpc –qnextgen --version icx (ICX) 2021.1 Beta 20191108 Copyright (C) 1985-2019 Intel Corporation. All rights reserved. This compiler is the 2021 Version compiler, ini al minor version and is a BETA compiler, build date was 20191108 .
Important Compiler Op ons Mapping • With the [-q|/Q]nextgen op on, ICC NextGen drivers icc, icpc or icl will accept ICC Classic compiler op ons OR Clang*/LLVM compiler op ons.
o Clang*/LLVM compiler op ons are interpreted directly. o Classic ICC compiler op ons passed to ICC NextGen are translated to their Clang*/LLVM equivalents, where possible.
• Without the [-q|/Q]nextgen op on (ICC Classic mode) ONLY ICC Classic op ons are accepted and the ICC Classic compiler is invoked (no ICC NextGen).
March 6, 2020 4 • Not all ICC Classic op ons are accepted and/or implemented in ICC NextGen. • Undocumented op ons from ICC Classic are NOT implemented and there are no plans to do so. Remember, this is a very different compiler – the old internal, undocumented ICC Classic op ons have no meaning or mapping to the ICC NextGen compiler. If there is func onality in an undocumented op on that you think you need, submit a bug report via Online Service Center (OSC), h ps://so ware.intel.com/en-us/support, explain the behavior you expect and how ICC NextGen is not providing what you need. “Because ICC accepted this op on and it’s in my makefile” is not jus fica on. This is a different compiler with different op miza ons and behavior. Try ICC NextGen without the op on.
• ICC Classic op ons: Diagnos c warnings are emi ed for ICC Classic op ons and are CURRENTLY not planned to be implemented in ICC NextGen.
command line warning #10430: Unsupported command line options encountered These options as listed are not supported with the compiler selected. For more information, use '-qnextgen-diag'. o ICC NextGen op on –qnextgen-diag causes the ICC NextGen compiler to emit a long list of ICC Classic op ons that are NOT accepted by ICC NextGen.
o If you have an unsupported op on that is important to your applica on AND removing it from your build flags with ICC NextGen leads to an error please REPORT AN ISSUE via OSC, h ps://so ware.intel.com/en-us/support. We would like to know which op ons you need implemented in ICC NextGen.
• ICC Classic op ons that ARE IMPLEMENTED or will be implemented soon are accepted quietly. • All Clang*/LLVM op ons for the Clang version included in ICC NextGen are accepted and implemented. However, some mes it maybe be necessary to pass op ons to Clang. If you need to or want to pass Clang op ons directly, use the op on
o -Xclang
▪ -target-feature +aes use -Xclang -target-feature -Xclang +aes o This -Xclang op on is for both Linux and Windows. • GNU* and Microso * compa ble op ons are accepted by ICC Classic and ICC NextGen.
Pragma Support Do NOT assume ICC or GCC pragmas are supported by ICC NextGen! ICC Classic had many proprietary Intel pragmas. Excluding OpenMP pragmas, only a subset of these Intel pragmas are supported in ICC NextGen. Thus,
March 6, 2020 5 WE RECOMMEND AS A FIRST PORTING STEP THAT YOU CHECK FOR UNSUPPORTED PRAGMAS! this can be done with the ICC NextGen supported option -Wunknown-pragmas: icc -qnextgen -Wunknown-pragmas
Consider this example: cat unknown-pragmas.c int main(void) { float arr[1000];
#pragma totallybogus #pragma simd #pragma vector for (int k=0; k<1000; k++) { arr[k] = 42.0; } }
icc -c -qnextgen -Wunknown-pragmas unknown-pragmas.c unknown-pragmas.c:4:9: warning: unknown pragma ignored [-Wunknown-pragmas] #pragma totallybogus ^ unknown-pragmas.c:5:9: warning: unknown pragma ignored [-Wunknown-pragmas] #pragma simd ^ 2 warnings generated.
Notice two things in this example. First “#pragma totallybogus” is a pragma that does not exist in ICC Classic, GCC, or ICC NextGen. It makes sense this pragma is called out as a warning. In the second case, “#pragma simd” WAS a supported pragma for ICC Classic. This pragma is NOT support in ICC NextGen. ICC NextGen will ignore this pragma and not do what the user expects from ICC Classic ( pragma SIMD should be replaced with OpenMP SIMD pragmas ). In the final case, “#pragma vector” is recognized and implemented by ICC NextGen and therefore there is no warning.
Predefined Macro Support Predefined macros documenta on is a work in progress. Macros are being added dynamically. For any given version of ICC NextGen use command: icc -qnextgen -x c /dev/null -dM –E to output the currently defined macros.
Built-In Func ons Clang* Built-In func ons are documented in the open source Clang documenta on. Intel-added Built-Ins for ICC NextGen is a work in progress.
March 6, 2020 6 Support for Pre-Compiled Header Files ICC NextGen supports creation of “relocatable” precompiled headers: These are built with a given path into your build directory, to be used later from an installed location. The option: --relocatable-pch enables this feature. More information on this can be found at https://clang.llvm.org/docs/ UsersManual.html#relocatable-pch-files.
This is a big improvement over ICC Classic, which had limitations with pre-compiled headers. The limitations of ICC Classic are documented at https://software.intel.com/en-us/articles/ unable-to-obtain-mapped-memory.
ICC NextGen uses the Clang method of crea ng and using Pre-Compiled Headers (PCH). It is a 2-step process, one to create and one to use. To create PCH: ( linux icc example, similar for Windows ) icc -qnextgen -x c-header file.h // creates file.h.gch To use PCH: icc -qnextgen -include-pch file.h.gch file.c // uses PCH file when compiling file.c
Changes in Diagnos cs Op ons and Diagnos c Message Numbering Current supported compiler diagnos c op ons: Linux op on Windows op on Replacement -diag-
The diag-
March 6, 2020 7 #pragma unknown_pragma Compiling with icc gives this warning message:
icc -c unknown-pragma.c unknown-pragma.c(1): warning #161: unrecognized #pragma #pragma unknown_pragma
The diagnos c warning #161 can be silenced by disabling that warning via the ICC Classic op on – diag-disable:161 to disable the unrecognized pragma diagnos c.
However, ICC NextGen does not have numbered diagnos c message. Instead, it will print a hint about which diagnos c op on can be used to control the diagnos c. You can use –Wall to enable all warning
icc -qnextgen -Wall -c ~/unknown-pragma.c unknown-pragma.c:1:9: warning: unknown pragma ignored [-Wunknown-pragmas] #pragma unknown_pragma diagnos cs that pertain to your program. The warning message suggests the op on that you can use to enable or disable that diagnos c. In ICC NextGen, the unknown pragma diagnos c is silent by default. To enable it, you can use –Wunknown-pragmas. To disable it, use –Wno-unknown-pragmas. Incidentally, you can always use the –Wno- prefix to disable any diagnos c.
To migrate your applica on’s diagnos c control op ons from exis ng ICC Classic projects, you will need to build your source with ICC NextGen and read through the diagnos c output, look for the suggested -Wno- op ons which disable the diagnos cs that you don’t wish to see and modify your build procedures to use those op ons.
To increase the severity of the diagnos c from warning to error, use –Werror=unknown-pragmas. This corresponds to ICC Classic op on –diag-error:161. ICC NextGen provides no method to decrease the severity of error messages.
About Clang Enhanced Diagnos cs The creators of the Clang compiler have put substan al effort in crea ng more useful diagnos c messages. You will find that the Clang diagnos cs are an improvement in several ways: 1. Colorized diagnos cs to make the diagnos c more readable, clearly dis nguishing between program source text and diagnos c text. 2. Precise source loca on informa on, including line and column number, as well as, range highligh ng for related text. 3. Fix-it hints, sugges ng how to correct the issue being reported. 4. Enhanced syntax error recovery, so that the issue can be reported exactly, as well as allowing compila on to con nue to find further issues. 5. And much more.
March 6, 2020 8 More informa on about clang’s expressive diagnos cs can be found at h ps://clang.llvm.org/ diagnos cs.html.
Linking, IPO and PGO changes The ICC NextGen compiler has different methods for both Interprocedural Op miza ons (IPO) and Profile Guided Op miza ons (PGO). If you are using these features, be aware of the following: • PGO: LLVM uses a completely different method for PGO. See the Ar cle Here for more informa on.
• IPO: LLVM uses “Link Time Op miza on” (LTO) technology for what ICC Classic termed “Interprocedural Op miza on” (IPO).
o More informa on on LLVM LTO is found in the Ar cle Here o Intel linker “xi*” tools removed: Intel tools ‘xilink’ ‘xild’ and ‘xiar’ have thus been removed from ICC NextGen as they serve no purpose – they are specific to the proprietary object file formats used by the Intel® Compilers.
o In your Makefiles or Project Se ngs if you have used ‘xilink’ or ‘xild’ replace these with the equivalent na ve linkers. Similarly replace ‘xiar’ with ‘ar’ or similar archive tool.
Language Features 1. Intel® Cilk™ Plus will not be supported in ICC NextGen compiler. Customers are expected to port their program from Intel Cilk Plus to OpenMP or Intel® TBB. You can use this KB ar cle on IDZ as reference: https://software.intel.com/en-us/articles/migrate-your-application-to-use- openmp-or-intelr-tbb-instead-of-intelr-cilktm-plus a. This include #PRAGMA SIMD, which appears in many ICC Classic-tuned codes from that era. PRAGMA SIMD should be replaced with OpenMP SIMD pragmas.
Intrinsic Usage Model Change • ICC NextGen does type checking for arguments to intrinsics when inlining whereas ICC Classic did not. Thus you may get warnings or errors from ICC NextGen about arguments to intrinsics that did not appear in ICC Classic. • ICC Classic does not demand using immintrin.h header file, as long as, we define __INTEL_COMPILER_USE_INTRINSIC_PROTOTYPES macro. • ICC Classic does not demand enabling specific processor/architecture specific compiler op on to use corresponding intrinsic. • These two above behaviors ARE NOT PROVIDED BY ICC NEXTGEN!! • How to use intrinsic based code with ICC NextGen • Use the compiler op on –march or –m
March 6, 2020 9 Example of LLVM Intrinsics Handling Differences Below is a simple example of type checking that ICC NextGen will do correctly compared to ICC Classic which will let a argument error pass: cat sample_mm_prefetch.c #include
#define CACHE_LINE_SIZE 64
__attribute__((always_inline)) inline void Prefetch_Block(const void* addr, size_t sz, int hint) { char* pref_addr = (char*)addr; size_t pref_iters = (sz + CACHE_LINE_SIZE - 1) / CACHE_LINE_SIZE;
for (int i = 0; i < pref_iters; i++) { _mm_prefetch(pref_addr, hint /*_MM_HINT_T1*/); pref_addr += CACHE_LINE_SIZE; }
$ icc -c sample_mm_prefetch.c
$ icc -qnextgen -c sample_mm_prefetch.c sample_mm_prefetch.c:13:9: error: argument to '__builtin_prefetch' must be a constant integer _mm_prefetch(pref_addr, hint /*_MM_HINT_T1*/); ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ /nfs/pdx/disks/cts2/tools/compiler/cpro/Compiler/19.1/initial/ compilers_and_libraries_2020.0.166/linux/lib/clang/10.0.0/include/ xmmintrin.h:2103:31: note: expanded from macro '_mm_prefetch' #define _mm_prefetch(a, sel) (__builtin_prefetch((void *)(a), \ ^ 1 error generated. compilation aborted for sample_mm_prefetch.c (code 1)
In this case the argument to_mm_prefetch should be a CONST, although the documenta on to intrinsic mm_prefetch does not specify this, this intrinsic is defined for a const argument. No ce that ICC Classic did not do the type checking whereas ICC NextGen did (correctly).
Below is a simple example demonstra ng the above change. (Note: The error diagnos cs are currently wrong when it comes to ISA recommenda on which is reported to open source community for fixing.)
$ cat intrinsic.cpp #include
March 6, 2020 10 y = _mm_set_ps1(1.f); for(int i = 0; i < N/4; i++) { x = _mm_load_ps(a); x = _mm_add_ps(x, y); _mm_store_ps(a, x); a+=4; } } void add_avx(float *a, int N){ __m256 x, y; y = _mm256_set_ps(1.f, 1.f, 1.f, 1.f, 1.f, 1.f, 1.f, 1.f); for(int i = 0; i < N/8; i++) { x = _mm256_load_ps(a); x = _mm256_add_ps(x, y); _mm256_store_ps(a, x); a+=8; } } void add_avx512(float *a, int N){ __m512 x, y; y = _mm512_set_ps(1.f, 1.f, 1.f, 1.f, 1.f, 1.f, 1.f, 1.f, 1.f, 1.f, 1.f, 1.f, 1.f, 1.f, 1.f, 1.f); for(int i = 0; i < N/16; i++) { x = _mm512_load_ps(a); x = _mm512_add_ps(x, y); _mm512_store_ps(a, x); a+=16; } } int main(){ float a[32]; for(int i = 0; i < 32; i++) a[i] = i; #ifdef SSE add_sse(a,32); #elif AVX add_avx(a,32); #else add_avx512(a,32); #endif std::cout<<"a[15] = "< The above code just compiles fines in ICC Classic, but not with ICC NextGen compiler as seen below: $ icpc -qnextgen intrinsic.cpp -DSSE intrinsic.cpp:19:13: error: always_inline function '_mm256_set_ps' requires target feature 'sse4.2', but would be inlined into function 'add_avx' that is compiled without support for 'sse4.2' March 6, 2020 11 y = _mm256_set_ps(1.f, 1.f, 1.f, 1.f, 1.f, 1.f, 1.f, 1.f); ^ intrinsic.cpp:22:21: error: always_inline function '_mm256_load_ps' requires target feature 'sse4.2', but would be inlined into function 'add_avx' that is compiled without support for 'sse4.2' x = _mm256_load_ps(a); ^ intrinsic.cpp:23:21: error: always_inline function '_mm256_add_ps' requires target feature 'sse4.2', but would be inlined into function 'add_avx' that is compiled without support for 'sse4.2' x = _mm256_add_ps(x, y); ^ intrinsic.cpp:24:17: error: always_inline function '_mm256_store_ps' requires target feature 'sse4.2', but would be inlined into function 'add_avx' that is compiled without support for 'sse4.2' _mm256_store_ps(a, x); ^ 4 errors generated. compilation aborted for intrinsic.cpp (code 1) Once we use the –mavx to enable Intel® AVX ISA, then the error pops up for AVX512 intrinsics. $ icpc -qnextgen intrinsic.cpp -DSSE -mavx intrinsic.cpp:31:13: error: always_inline function '_mm512_set_ps' requires target feature 'avx2', but would be inlined into function 'add_avx512' that is compiled without support for 'avx2' y = _mm512_set_ps(1.f, 1.f, 1.f, 1.f, 1.f, 1.f, 1.f, 1.f, 1.f, 1.f, 1.f, 1.f, 1.f, 1.f, 1.f, 1.f); ^ intrinsic.cpp:34:21: error: always_inline function '_mm512_load_ps' requires target feature 'avx2', but would be inlined into function 'add_avx512' that is compiled without support for 'avx2' x = _mm512_load_ps(a); ^ intrinsic.cpp:35:21: error: always_inline function '_mm512_add_ps' requires target feature 'avx2', but would be inlined into function 'add_avx512' that is compiled without support for 'avx2' x = _mm512_add_ps(x, y); ^ intrinsic.cpp:36:17: error: always_inline function '_mm512_store_ps' requires target feature 'avx2', but would be inlined into function 'add_avx512' that is compiled without support for 'avx2' _mm512_store_ps(a, x); ^ 4 errors generated. compilation aborted for intrinsic.cpp (code 1) Enable the Intel® AVX-512 ISA using –mavx512f compiler op on and the error goes away. March 6, 2020 12 Intrinsics Via Func on Defini on __attribute__((target())) In the above example we used a compiler op on to target a specific instruc on set ( -mavx512f ). This can be used if just one instruc on set exists in the source file. O en, source files will contain mul ple instruc on sets represented in intrinsic data declara ons and intrinsic instruc ons. This is done to call specific func ons or code sec ons based on the run me processor discovery. Typically, these func ons or code sec ons are protected by #IFDEFs with specific target architectures and the user code does processor dispatch to these sec ons or func ons. The Clang/LLVM community highly encourages users to mark func on defini ons using the gcc-style a ribute target: __attribute__((target( An example of Mul -versioning: #include __attribute__ ((target("avx2"))) void dispatch_func() { printf("\nCode for Intel Core processors supporting Intel AVX2 goes here\n"); } __attribute__ ((target("sse4.2"))) void dispatch_func() { printf("\nCode for Intel Core processors supporting SSE4.2 goes here\n"); } __attribute__ ((target("sse3"))) void dispatch_func() { printf("\nCode for Intel Core 2 Duo processors supporting SSSE3 goes here\n"); } __attribute__ ((target("default"))) void dispatch_func() { printf("\nCode for default implementation goes here\n"); March 6, 2020 13 }; int main() { dispatch_func(); printf("Return from dispatch_func\n"); return 0; } Intel Proprietary Processsor Targe ng Pragmas and Func ons Support • Intel proprietary pragmas “op miza on_parameter *”: #pragma [intel] optimization_parameter target_arch= • Intel proprietary intrinsic func on _allow_cpu_features(): As of 2019 we currently do not support _allow_cpu_features(), but it may be added some me in 2020. Keep checking for availability of this func on. • Intel proprietary “#pragma simd” was removed from ICC Classic 19.1 and is not supported in ICC NextGen. Replace with OpenMP SIMD “#pragma omp simd” and it’s clauses and compile with -fiopenmp or -fiopenmp-simd Legacy Intrinsics Promo on with Op on intrinsic-promote: Not recommended but available. Finally, for legacy applica ons with ICC Classic style intrinsics, the ICC NextGen compiler provides a new op on. We discourage use of this op on as it is error-prone. This op on a empts to automa cally promote func ons containing intrinsics to the maximum target architecture of the intrinsics inside that func on. A func on containing sec ons with differing targe ng (user processor dispatched, for example) can cause run me faults. For this reason, we do not encourage this op on. We are working on be er long-term solu ons for legacy ICC Classic intrinsics behavior. Windows syntax: /Qintrinsic-promote Linux syntax: -mintrinsic-promote If this op on is used, func ons containing calls to intrinsics that require a specific CPU feature will have their target architecture automa cally promoted to allow the required feature. All code within the func on will be compiled with that target architecture and the resul ng code for such func ons will not March 6, 2020 14 execute correctly on processors that do not support the required feature. The user is responsible for guarding the execu on path at run me so that such func ons are not dynamically reachable when the program is run on processors that do not support the required feature. This op on is provided as a convenience for compiling legacy code. Users are strongly encouraged to use __attribute__((target( Floa ng Point Reproducibility Controls The current state of the floa ng point (FP) model support in ICC NextGen: • The default FP model is value-safe, equivalent to -fp-model precise -no-fma. This is major behavioral difference between ICC Classic and ICC NextGen. We believe it to be a good customer friendly difference. (note: April 9 2020: this is s ll the default for beta05. But in a future beta we may change this to -fp-model precise -fma. Please check Release Notes for the latest default.) • • -fp-model fast is supported. There is no difference between fast=1 and fast=2 currently. • FP Strictness: Nothing stricter than the default is supported. There is no support for -fp-model strict, -fp-speculation=safe, #pragma fenv_access, etc. Implemen ng support for these is a work-in-progress in the open source community. • The math library related features in ICC Classic are currently being ported to ICC NextGen. We have implemented the IMF (Intel® Math Library) a ributes in ICC NextGen. Brutus or Bisec onal Op miza on Support If you have never heard of “Brutus” in ICC Classic or Bisec onal Op miza ons in Clang/LLVM, you may skip this sec on. ICC NextGen has support for Clang/LLVM –opt-bisect-limit=N for bisec onal op miza on debug. This is instead of ICC Classic Brutus op ons. A community effort is underway to enhance op miza on debugging capabili es in Clang/LLVM via the open source community. More informa on at h ps://llvm.org/docs/OptBisect.html. Appendix I: ICC Classic Compiler Op ons Status Op ons which are not planned to be implemented, but could be considered if requested or needed by an applica on Linux Windows -finline-limit /Qinline-factor -keep-inline-func ons /Qinline-max-per-compile March 6, 2020 15 -finstrument-func ons /Qinline-max-per-rou ne -gcc-extern-inline /Qinline-max-size -inline-level /Qinline-max-total-size -inline-factor /Qinline-min-size -inline-max-per-compile /Qinstrument-func ons -inline-max-per-rou ne /Qipo -inline-max-size /Qprof-data-order -inline-max-total-size /Qprof-order -inline-min-size /Qprof-value-profiling -inline-min-caller-growth -ipo -prof-data-order -prof-value-profiling Op ons under considera on but not implemented currently Linux Windows -auto-ilp32 /Qauto-ilp32 -auto-p32 -Ofast -diag-enable=power /Qdiag-enable:power Op ons which will not be implemented Linux Windows -comp-obj /Qcomp-obj -from-obj /Q_ipo-list -from-rtn /Q_prof-loop -i_ipo_list /Qfrom-obj -i_prof-loop /Qto-obj -inl-heur /Qhprof-dir -ip /Qhprof-exe March 6, 2020 16 -ip-no-inlining /Qhprof-file -ip-no-pinlining /Qinl-heur -no-ipo /Qip -ipo-c /Qip-no-inlining -ipo-il /Qip-no-pinlining -ipo-jobs /Qipo-c -ipo-S /Qipo-il -ipo-save /Qipo-jobs -ipo-separate /Qipo-S -num-case /Qipo-save -num-obj /Qipo-separate -num-opt /Qnum-case -num-rtn /Qnum-obj -override-limits /Qnum-opt -prof-file /Qnum-rtn -prof-gen /Qopt-overridelimits -prof-hpi /Qprof-file -prof-use /Qprof-gen -prof-gen-sampling /Qprof-gen-sampling -prof-use-sampling /Qprof-hpi -profile-func ons /Qprofile-func ons -profile-loops /Qprofile-loops -profile-loops-report /Qprofile-loops-report -tcollect /Qprof-use -tcollect-filter /Qprof-use-sampling -to-obj /Qtcollect -to-rtn /Qtcollect-filter /Qto-obj /Qto-rtn -diag- March 6, 2020 17 -diag-once /Qdiag-once New Op ons to ICC NextGen (not supported by Clang currently) Linux Windows -mintrinsic-promote /Qinstrinsic-promote March 6, 2020 18