Note: The GNU Compiler Collection provides a wide array of compiler options, described in detail and readily available at https://gcc.gnu.org/onlinedocs/gcc/Option-Index.html#Option-Index and https://gcc.gnu.org/onlinedocs/gfortran/. This SPEC CPU flags file contains excerpts from and brief summaries of portions of that documentation.
SPEC's modifications are:
Copyright 2006-2026 Standard Performance Evaluation Corporation
Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.3 or any later version published by the Free Software Foundation; with the Invariant Sections being "Funding Free Software", the Front-Cover Texts being (a) (see below), and with the Back-Cover Texts being (b) (see below). A copy of the license is included in your SPEC CPU kit at $SPEC/Docs/licenses/FDL.v1.3.txt and on the web at https://www.spec.org/cpu2026/Docs/licenses/FDL.v1.3.txt. A copy of "Funding Free Software" is on your SPEC CPU kit at $SPEC/Docs/licenses/FundingFreeSW.txt and on the web at https://www.spec.org/cpu2026/Docs/licenses/FundingFreeSW.txt.
(a) The FSF's Front-Cover Text is:
A GNU Manual
(b) The FSF's Back-Cover Text is:
You have freedom to copy and modify this GNU Manual, like GNU software. Copies published by the Free Software Foundation raise funds for GNU development.
![[user]](https://www.spec.org/auto/cpu2026/images/user.png)
Invokes the GNU C compiler.
Invokes the GNU C++ compiler.
Invokes the GNU C++ compiler.
Invokes the GNU C compiler.
Invokes the GNU C compiler.
Invokes the GNU C++ compiler.
Invokes the GNU C++ compiler.
Invokes the GNU C compiler.
Do not allow optimizations for floating-point arithmetic that assume that arguments and results are not NaNs or +-Infs.
A SPEC CPU config file might use this flag in combination with -Ofast, to specify that all the optimizations of -Ofast are desired, with the exception of -ffinite-math-only.
You may need to use this flag in order to get certain benchmarks to validate. If it is needed, the normal rules about portability flags apply.
Do not allow optimizations for floating-point arithmetic that assume that arguments and results are not NaNs or +-Infs.
A SPEC CPU config file might use this flag in combination with -Ofast, to specify that all the optimizations of -Ofast are desired, with the exception of -ffinite-math-only.
You may need to use this flag in order to get certain benchmarks to validate. If it is needed, the normal rules about portability flags apply.
Do not allow optimizations for floating-point arithmetic that assume that arguments and results are not NaNs or +-Infs.
A SPEC CPU config file might use this flag in combination with -Ofast, to specify that all the optimizations of -Ofast are desired, with the exception of -ffinite-math-only.
You may need to use this flag in order to get certain benchmarks to validate. If it is needed, the normal rules about portability flags apply.
Do not allow optimizations for floating-point arithmetic that assume that arguments and results are not NaNs or +-Infs.
A SPEC CPU config file might use this flag in combination with -Ofast, to specify that all the optimizations of -Ofast are desired, with the exception of -ffinite-math-only.
You may need to use this flag in order to get certain benchmarks to validate. If it is needed, the normal rules about portability flags apply.
Do not allow optimizations for floating-point arithmetic that assume that arguments and results are not NaNs or +-Infs.
A SPEC CPU config file might use this flag in combination with -Ofast, to specify that all the optimizations of -Ofast are desired, with the exception of -ffinite-math-only.
You may need to use this flag in order to get certain benchmarks to validate. If it is needed, the normal rules about portability flags apply.
Do not allow optimizations for floating-point arithmetic that assume that arguments and results are not NaNs or +-Infs.
A SPEC CPU config file might use this flag in combination with -Ofast, to specify that all the optimizations of -Ofast are desired, with the exception of -ffinite-math-only.
You may need to use this flag in order to get certain benchmarks to validate. If it is needed, the normal rules about portability flags apply.
Generate code for lp64. With ilp32, int, long int and pointer are 32-bit; with lp64, int is 32-bit, but long int and pointer are 64-bit.
Sets the language standard to the specified version, for example c18, c++17, f2008.
Allow multiple definitions of the same symbols instead of failing with an error. The symbols in jemalloc may conflict with symbols in glibc when using static linking, and this flag will cause the linker to continue instead of failing.
On systems that support dynamic linking, this overrides -pie and prevents linking with the shared libraries. On other systems, this option has no effect.
Assume that the current compilation unit represents the whole program being compiled. All public functions and variables with the exception of main and those merged by attribute externally_visible become static functions and in effect are optimized more aggressively by interprocedural optimizers.
Add the specified path to the list of paths that the linker will search for archive libraries and control scripts.
Add the specified path to the list of paths that the linker will search for archive libraries and control scripts.
Add the specified path to the list of paths that the linker will search for archive libraries and control scripts.
Produce debugging information.
Disregard strict standards compliance. -Ofast enables all -O3 optimizations. It also enables optimizations that are not valid for all standard-compliant programs. It turns on -ffast-math, -fallow-store-data-races (as of GCC 10), and the Fortran-specific -fstack-arrays unless -fmax-stack-var-size is specified, and -fno-protect-parens.
On aarch64 systems, -mcpu sets the kind of instructions that can be used (as if by -march) and how to tune for performance (as if by -mtune).
On x86 systems, -mcpu is a deprecated synonym for -mtune.
Enables link time optimization. When invoked with source code, it generates GIMPLE (one of GCC's internal representations) and writes it to special ELF sections in the object file. When the object files are linked together, all the function bodies are read from these ELF sections and instantiated as if they had been part of the same translation unit.
Tells the optimizer to unroll loops whose number of iterations can be determined at compile time or upon entry to the loop.
Specify growth that the early inliner can make. In effect it increases the amount of inlining for code having a large abstraction penalty.
When you use -finline-functions (included in -O3), a lot of functions that would otherwise not be considered for inlining by the compiler are investigated. To those functions, a different (more restrictive) limit compared to functions declared inline can be applied.
Specifies maximal overall growth of the compilation unit caused by inlining. For example, parameter value 20 limits unit growth to 1.2 times the original size. Cold functions (either marked cold via an attribute or by profile feedback) are not accounted into the unit size.
Treat the specified symbol as undefined, to force linking of library modules to define it. You can use -u multiple times with different symbols to force loading of additional library modules. E.g., "-u malloc -ljemalloc" can guarantee linking the malloc() defined in the jemalloc library. Without it, the linking options order change may cause a failure to link jemalloc.
Link with libjemalloc, a fast, arena-based memory allocator.
Generate code for lp64. With ilp32, int, long int and pointer are 32-bit; with lp64, int is 32-bit, but long int and pointer are 64-bit.
Sets the language standard to the specified version, for example c18, c++17, f2008.
Allow multiple definitions of the same symbols instead of failing with an error. The symbols in jemalloc may conflict with symbols in glibc when using static linking, and this flag will cause the linker to continue instead of failing.
On systems that support dynamic linking, this overrides -pie and prevents linking with the shared libraries. On other systems, this option has no effect.
Assume that the current compilation unit represents the whole program being compiled. All public functions and variables with the exception of main and those merged by attribute externally_visible become static functions and in effect are optimized more aggressively by interprocedural optimizers.
Add the specified path to the list of paths that the linker will search for archive libraries and control scripts.
Add the specified path to the list of paths that the linker will search for archive libraries and control scripts.
Add the specified path to the list of paths that the linker will search for archive libraries and control scripts.
Produce debugging information.
Disregard strict standards compliance. -Ofast enables all -O3 optimizations. It also enables optimizations that are not valid for all standard-compliant programs. It turns on -ffast-math, -fallow-store-data-races (as of GCC 10), and the Fortran-specific -fstack-arrays unless -fmax-stack-var-size is specified, and -fno-protect-parens.
On aarch64 systems, -mcpu sets the kind of instructions that can be used (as if by -march) and how to tune for performance (as if by -mtune).
On x86 systems, -mcpu is a deprecated synonym for -mtune.
Enables link time optimization. When invoked with source code, it generates GIMPLE (one of GCC's internal representations) and writes it to special ELF sections in the object file. When the object files are linked together, all the function bodies are read from these ELF sections and instantiated as if they had been part of the same translation unit.
Tells the optimizer to unroll loops whose number of iterations can be determined at compile time or upon entry to the loop.
Specify growth that the early inliner can make. In effect it increases the amount of inlining for code having a large abstraction penalty.
When you use -finline-functions (included in -O3), a lot of functions that would otherwise not be considered for inlining by the compiler are investigated. To those functions, a different (more restrictive) limit compared to functions declared inline can be applied.
Specifies maximal overall growth of the compilation unit caused by inlining. For example, parameter value 20 limits unit growth to 1.2 times the original size. Cold functions (either marked cold via an attribute or by profile feedback) are not accounted into the unit size.
Assume that a loop with an exit will eventually take the exit and not loop indefinitely. This allows the compiler to remove loops that otherwise have no side-effects, not considering eventual endless looping as such.
Enable support for POSIX Threads. Note that C++ programs using std::thread may require this flag.
Treat the specified symbol as undefined, to force linking of library modules to define it. You can use -u multiple times with different symbols to force loading of additional library modules. E.g., "-u malloc -ljemalloc" can guarantee linking the malloc() defined in the jemalloc library. Without it, the linking options order change may cause a failure to link jemalloc.
Link with libjemalloc, a fast, arena-based memory allocator.
Generate code for lp64. With ilp32, int, long int and pointer are 32-bit; with lp64, int is 32-bit, but long int and pointer are 64-bit.
Sets the language standard to the specified version, for example c18, c++17, f2008.
Allow multiple definitions of the same symbols instead of failing with an error. The symbols in jemalloc may conflict with symbols in glibc when using static linking, and this flag will cause the linker to continue instead of failing.
On systems that support dynamic linking, this overrides -pie and prevents linking with the shared libraries. On other systems, this option has no effect.
Assume that the current compilation unit represents the whole program being compiled. All public functions and variables with the exception of main and those merged by attribute externally_visible become static functions and in effect are optimized more aggressively by interprocedural optimizers.
Add the specified path to the list of paths that the linker will search for archive libraries and control scripts.
Add the specified path to the list of paths that the linker will search for archive libraries and control scripts.
Add the specified path to the list of paths that the linker will search for archive libraries and control scripts.
Produce debugging information.
Disregard strict standards compliance. -Ofast enables all -O3 optimizations. It also enables optimizations that are not valid for all standard-compliant programs. It turns on -ffast-math, -fallow-store-data-races (as of GCC 10), and the Fortran-specific -fstack-arrays unless -fmax-stack-var-size is specified, and -fno-protect-parens.
On aarch64 systems, -mcpu sets the kind of instructions that can be used (as if by -march) and how to tune for performance (as if by -mtune).
On x86 systems, -mcpu is a deprecated synonym for -mtune.
Enables link time optimization. When invoked with source code, it generates GIMPLE (one of GCC's internal representations) and writes it to special ELF sections in the object file. When the object files are linked together, all the function bodies are read from these ELF sections and instantiated as if they had been part of the same translation unit.
Tells the optimizer to unroll loops whose number of iterations can be determined at compile time or upon entry to the loop.
Specify growth that the early inliner can make. In effect it increases the amount of inlining for code having a large abstraction penalty.
When you use -finline-functions (included in -O3), a lot of functions that would otherwise not be considered for inlining by the compiler are investigated. To those functions, a different (more restrictive) limit compared to functions declared inline can be applied.
Specifies maximal overall growth of the compilation unit caused by inlining. For example, parameter value 20 limits unit growth to 1.2 times the original size. Cold functions (either marked cold via an attribute or by profile feedback) are not accounted into the unit size.
Assume that a loop with an exit will eventually take the exit and not loop indefinitely. This allows the compiler to remove loops that otherwise have no side-effects, not considering eventual endless looping as such.
Treat the specified symbol as undefined, to force linking of library modules to define it. You can use -u multiple times with different symbols to force loading of additional library modules. E.g., "-u malloc -ljemalloc" can guarantee linking the malloc() defined in the jemalloc library. Without it, the linking options order change may cause a failure to link jemalloc.
Link with libjemalloc, a fast, arena-based memory allocator.
Generate code for lp64. With ilp32, int, long int and pointer are 32-bit; with lp64, int is 32-bit, but long int and pointer are 64-bit.
Sets the language standard to the specified version, for example c18, c++17, f2008.
Sets the language standard to the specified version, for example c18, c++17, f2008.
Allow multiple definitions of the same symbols instead of failing with an error. The symbols in jemalloc may conflict with symbols in glibc when using static linking, and this flag will cause the linker to continue instead of failing.
On systems that support dynamic linking, this overrides -pie and prevents linking with the shared libraries. On other systems, this option has no effect.
Assume that the current compilation unit represents the whole program being compiled. All public functions and variables with the exception of main and those merged by attribute externally_visible become static functions and in effect are optimized more aggressively by interprocedural optimizers.
Add the specified path to the list of paths that the linker will search for archive libraries and control scripts.
Add the specified path to the list of paths that the linker will search for archive libraries and control scripts.
Add the specified path to the list of paths that the linker will search for archive libraries and control scripts.
Produce debugging information.
Disregard strict standards compliance. -Ofast enables all -O3 optimizations. It also enables optimizations that are not valid for all standard-compliant programs. It turns on -ffast-math, -fallow-store-data-races (as of GCC 10), and the Fortran-specific -fstack-arrays unless -fmax-stack-var-size is specified, and -fno-protect-parens.
On aarch64 systems, -mcpu sets the kind of instructions that can be used (as if by -march) and how to tune for performance (as if by -mtune).
On x86 systems, -mcpu is a deprecated synonym for -mtune.
Enables link time optimization. When invoked with source code, it generates GIMPLE (one of GCC's internal representations) and writes it to special ELF sections in the object file. When the object files are linked together, all the function bodies are read from these ELF sections and instantiated as if they had been part of the same translation unit.
Tells the optimizer to unroll loops whose number of iterations can be determined at compile time or upon entry to the loop.
Specify growth that the early inliner can make. In effect it increases the amount of inlining for code having a large abstraction penalty.
When you use -finline-functions (included in -O3), a lot of functions that would otherwise not be considered for inlining by the compiler are investigated. To those functions, a different (more restrictive) limit compared to functions declared inline can be applied.
Specifies maximal overall growth of the compilation unit caused by inlining. For example, parameter value 20 limits unit growth to 1.2 times the original size. Cold functions (either marked cold via an attribute or by profile feedback) are not accounted into the unit size.
Specify growth that the early inliner can make. In effect it increases the amount of inlining for code having a large abstraction penalty.
When you use -finline-functions (included in -O3), a lot of functions that would otherwise not be considered for inlining by the compiler are investigated. To those functions, a different (more restrictive) limit compared to functions declared inline can be applied.
Specifies maximal overall growth of the compilation unit caused by inlining. For example, parameter value 20 limits unit growth to 1.2 times the original size. Cold functions (either marked cold via an attribute or by profile feedback) are not accounted into the unit size.
Assume that a loop with an exit will eventually take the exit and not loop indefinitely. This allows the compiler to remove loops that otherwise have no side-effects, not considering eventual endless looping as such.
Treat the specified symbol as undefined, to force linking of library modules to define it. You can use -u multiple times with different symbols to force loading of additional library modules. E.g., "-u malloc -ljemalloc" can guarantee linking the malloc() defined in the jemalloc library. Without it, the linking options order change may cause a failure to link jemalloc.
Link with libjemalloc, a fast, arena-based memory allocator.
Generate code for lp64. With ilp32, int, long int and pointer are 32-bit; with lp64, int is 32-bit, but long int and pointer are 64-bit.
Sets the language standard to the specified version, for example c18, c++17, f2008.
Sets the language standard to the specified version, for example c18, c++17, f2008.
Allow multiple definitions of the same symbols instead of failing with an error. The symbols in jemalloc may conflict with symbols in glibc when using static linking, and this flag will cause the linker to continue instead of failing.
On systems that support dynamic linking, this overrides -pie and prevents linking with the shared libraries. On other systems, this option has no effect.
Assume that the current compilation unit represents the whole program being compiled. All public functions and variables with the exception of main and those merged by attribute externally_visible become static functions and in effect are optimized more aggressively by interprocedural optimizers.
Add the specified path to the list of paths that the linker will search for archive libraries and control scripts.
Add the specified path to the list of paths that the linker will search for archive libraries and control scripts.
Add the specified path to the list of paths that the linker will search for archive libraries and control scripts.
Produce debugging information.
Disregard strict standards compliance. -Ofast enables all -O3 optimizations. It also enables optimizations that are not valid for all standard-compliant programs. It turns on -ffast-math, -fallow-store-data-races (as of GCC 10), and the Fortran-specific -fstack-arrays unless -fmax-stack-var-size is specified, and -fno-protect-parens.
On aarch64 systems, -mcpu sets the kind of instructions that can be used (as if by -march) and how to tune for performance (as if by -mtune).
On x86 systems, -mcpu is a deprecated synonym for -mtune.
Enables link time optimization. When invoked with source code, it generates GIMPLE (one of GCC's internal representations) and writes it to special ELF sections in the object file. When the object files are linked together, all the function bodies are read from these ELF sections and instantiated as if they had been part of the same translation unit.
Tells the optimizer to unroll loops whose number of iterations can be determined at compile time or upon entry to the loop.
Specify growth that the early inliner can make. In effect it increases the amount of inlining for code having a large abstraction penalty.
When you use -finline-functions (included in -O3), a lot of functions that would otherwise not be considered for inlining by the compiler are investigated. To those functions, a different (more restrictive) limit compared to functions declared inline can be applied.
Specifies maximal overall growth of the compilation unit caused by inlining. For example, parameter value 20 limits unit growth to 1.2 times the original size. Cold functions (either marked cold via an attribute or by profile feedback) are not accounted into the unit size.
Specify growth that the early inliner can make. In effect it increases the amount of inlining for code having a large abstraction penalty.
When you use -finline-functions (included in -O3), a lot of functions that would otherwise not be considered for inlining by the compiler are investigated. To those functions, a different (more restrictive) limit compared to functions declared inline can be applied.
Specifies maximal overall growth of the compilation unit caused by inlining. For example, parameter value 20 limits unit growth to 1.2 times the original size. Cold functions (either marked cold via an attribute or by profile feedback) are not accounted into the unit size.
Assume that a loop with an exit will eventually take the exit and not loop indefinitely. This allows the compiler to remove loops that otherwise have no side-effects, not considering eventual endless looping as such.
Enable support for POSIX Threads. Note that C++ programs using std::thread may require this flag.
Treat the specified symbol as undefined, to force linking of library modules to define it. You can use -u multiple times with different symbols to force loading of additional library modules. E.g., "-u malloc -ljemalloc" can guarantee linking the malloc() defined in the jemalloc library. Without it, the linking options order change may cause a failure to link jemalloc.
Link with libjemalloc, a fast, arena-based memory allocator.
Generate code for lp64. With ilp32, int, long int and pointer are 32-bit; with lp64, int is 32-bit, but long int and pointer are 64-bit.
Sets the language standard to the specified version, for example c18, c++17, f2008.
Allow multiple definitions of the same symbols instead of failing with an error. The symbols in jemalloc may conflict with symbols in glibc when using static linking, and this flag will cause the linker to continue instead of failing.
On systems that support dynamic linking, this overrides -pie and prevents linking with the shared libraries. On other systems, this option has no effect.
Assume that the current compilation unit represents the whole program being compiled. All public functions and variables with the exception of main and those merged by attribute externally_visible become static functions and in effect are optimized more aggressively by interprocedural optimizers.
Add the specified path to the list of paths that the linker will search for archive libraries and control scripts.
Add the specified path to the list of paths that the linker will search for archive libraries and control scripts.
Add the specified path to the list of paths that the linker will search for archive libraries and control scripts.
Instruments code to collect information for profile-driven feedback. Information is collected regarding both code paths and data values.
Applies information from a profile run in order to improve optimization. Several optimizations are improved when profile data is available, including branch probabilities, loop peeling, and loop unrolling.
With -fprofile-use all portions of programs not executed during the training run are aggressively optimized for size rather than speed. In some cases it is not practical to train all possible hot paths in the program. (For example, the program may contain functions specific to some given hardware and training may not cover all hardware configurations the program is run on.) With -fprofile-partial-training profile feedback will be ignored for all functions not executed during the training run leading them to be optimized as if they were compiled without profile feedback. This leads to better performance when the training run is not representative but also leads to significantly larger generated code.
Produce debugging information.
Disregard strict standards compliance. -Ofast enables all -O3 optimizations. It also enables optimizations that are not valid for all standard-compliant programs. It turns on -ffast-math, -fallow-store-data-races (as of GCC 10), and the Fortran-specific -fstack-arrays unless -fmax-stack-var-size is specified, and -fno-protect-parens.
On aarch64 systems, -mcpu sets the kind of instructions that can be used (as if by -march) and how to tune for performance (as if by -mtune).
On x86 systems, -mcpu is a deprecated synonym for -mtune.
Enables link time optimization. When invoked with source code, it generates GIMPLE (one of GCC's internal representations) and writes it to special ELF sections in the object file. When the object files are linked together, all the function bodies are read from these ELF sections and instantiated as if they had been part of the same translation unit.
Tells the optimizer to unroll loops whose number of iterations can be determined at compile time or upon entry to the loop.
Specify growth that the early inliner can make. In effect it increases the amount of inlining for code having a large abstraction penalty.
When you use -finline-functions (included in -O3), a lot of functions that would otherwise not be considered for inlining by the compiler are investigated. To those functions, a different (more restrictive) limit compared to functions declared inline can be applied.
Specifies maximal overall growth of the compilation unit caused by inlining. For example, parameter value 20 limits unit growth to 1.2 times the original size. Cold functions (either marked cold via an attribute or by profile feedback) are not accounted into the unit size.
Treat the specified symbol as undefined, to force linking of library modules to define it. You can use -u multiple times with different symbols to force loading of additional library modules. E.g., "-u malloc -ljemalloc" can guarantee linking the malloc() defined in the jemalloc library. Without it, the linking options order change may cause a failure to link jemalloc.
Link with libjemalloc, a fast, arena-based memory allocator.
Generate code for lp64. With ilp32, int, long int and pointer are 32-bit; with lp64, int is 32-bit, but long int and pointer are 64-bit.
Sets the language standard to the specified version, for example c18, c++17, f2008.
Allow multiple definitions of the same symbols instead of failing with an error. The symbols in jemalloc may conflict with symbols in glibc when using static linking, and this flag will cause the linker to continue instead of failing.
On systems that support dynamic linking, this overrides -pie and prevents linking with the shared libraries. On other systems, this option has no effect.
Assume that the current compilation unit represents the whole program being compiled. All public functions and variables with the exception of main and those merged by attribute externally_visible become static functions and in effect are optimized more aggressively by interprocedural optimizers.
Add the specified path to the list of paths that the linker will search for archive libraries and control scripts.
Add the specified path to the list of paths that the linker will search for archive libraries and control scripts.
Add the specified path to the list of paths that the linker will search for archive libraries and control scripts.
Instruments code to collect information for profile-driven feedback. Information is collected regarding both code paths and data values.
Applies information from a profile run in order to improve optimization. Several optimizations are improved when profile data is available, including branch probabilities, loop peeling, and loop unrolling.
With -fprofile-use all portions of programs not executed during the training run are aggressively optimized for size rather than speed. In some cases it is not practical to train all possible hot paths in the program. (For example, the program may contain functions specific to some given hardware and training may not cover all hardware configurations the program is run on.) With -fprofile-partial-training profile feedback will be ignored for all functions not executed during the training run leading them to be optimized as if they were compiled without profile feedback. This leads to better performance when the training run is not representative but also leads to significantly larger generated code.
Produce debugging information.
Disregard strict standards compliance. -Ofast enables all -O3 optimizations. It also enables optimizations that are not valid for all standard-compliant programs. It turns on -ffast-math, -fallow-store-data-races (as of GCC 10), and the Fortran-specific -fstack-arrays unless -fmax-stack-var-size is specified, and -fno-protect-parens.
On aarch64 systems, -mcpu sets the kind of instructions that can be used (as if by -march) and how to tune for performance (as if by -mtune).
On x86 systems, -mcpu is a deprecated synonym for -mtune.
Enables link time optimization. When invoked with source code, it generates GIMPLE (one of GCC's internal representations) and writes it to special ELF sections in the object file. When the object files are linked together, all the function bodies are read from these ELF sections and instantiated as if they had been part of the same translation unit.
Tells the optimizer to unroll loops whose number of iterations can be determined at compile time or upon entry to the loop.
Specify growth that the early inliner can make. In effect it increases the amount of inlining for code having a large abstraction penalty.
When you use -finline-functions (included in -O3), a lot of functions that would otherwise not be considered for inlining by the compiler are investigated. To those functions, a different (more restrictive) limit compared to functions declared inline can be applied.
Specifies maximal overall growth of the compilation unit caused by inlining. For example, parameter value 20 limits unit growth to 1.2 times the original size. Cold functions (either marked cold via an attribute or by profile feedback) are not accounted into the unit size.
Assume that a loop with an exit will eventually take the exit and not loop indefinitely. This allows the compiler to remove loops that otherwise have no side-effects, not considering eventual endless looping as such.
Enable support for POSIX Threads. Note that C++ programs using std::thread may require this flag.
Treat the specified symbol as undefined, to force linking of library modules to define it. You can use -u multiple times with different symbols to force loading of additional library modules. E.g., "-u malloc -ljemalloc" can guarantee linking the malloc() defined in the jemalloc library. Without it, the linking options order change may cause a failure to link jemalloc.
Link with libjemalloc, a fast, arena-based memory allocator.
Generate code for lp64. With ilp32, int, long int and pointer are 32-bit; with lp64, int is 32-bit, but long int and pointer are 64-bit.
Sets the language standard to the specified version, for example c18, c++17, f2008.
Allow multiple definitions of the same symbols instead of failing with an error. The symbols in jemalloc may conflict with symbols in glibc when using static linking, and this flag will cause the linker to continue instead of failing.
On systems that support dynamic linking, this overrides -pie and prevents linking with the shared libraries. On other systems, this option has no effect.
Assume that the current compilation unit represents the whole program being compiled. All public functions and variables with the exception of main and those merged by attribute externally_visible become static functions and in effect are optimized more aggressively by interprocedural optimizers.
Add the specified path to the list of paths that the linker will search for archive libraries and control scripts.
Add the specified path to the list of paths that the linker will search for archive libraries and control scripts.
Add the specified path to the list of paths that the linker will search for archive libraries and control scripts.
Instruments code to collect information for profile-driven feedback. Information is collected regarding both code paths and data values.
Applies information from a profile run in order to improve optimization. Several optimizations are improved when profile data is available, including branch probabilities, loop peeling, and loop unrolling.
With -fprofile-use all portions of programs not executed during the training run are aggressively optimized for size rather than speed. In some cases it is not practical to train all possible hot paths in the program. (For example, the program may contain functions specific to some given hardware and training may not cover all hardware configurations the program is run on.) With -fprofile-partial-training profile feedback will be ignored for all functions not executed during the training run leading them to be optimized as if they were compiled without profile feedback. This leads to better performance when the training run is not representative but also leads to significantly larger generated code.
Produce debugging information.
Disregard strict standards compliance. -Ofast enables all -O3 optimizations. It also enables optimizations that are not valid for all standard-compliant programs. It turns on -ffast-math, -fallow-store-data-races (as of GCC 10), and the Fortran-specific -fstack-arrays unless -fmax-stack-var-size is specified, and -fno-protect-parens.
On aarch64 systems, -mcpu sets the kind of instructions that can be used (as if by -march) and how to tune for performance (as if by -mtune).
On x86 systems, -mcpu is a deprecated synonym for -mtune.
Enables link time optimization. When invoked with source code, it generates GIMPLE (one of GCC's internal representations) and writes it to special ELF sections in the object file. When the object files are linked together, all the function bodies are read from these ELF sections and instantiated as if they had been part of the same translation unit.
Tells the optimizer to unroll loops whose number of iterations can be determined at compile time or upon entry to the loop.
Specify growth that the early inliner can make. In effect it increases the amount of inlining for code having a large abstraction penalty.
When you use -finline-functions (included in -O3), a lot of functions that would otherwise not be considered for inlining by the compiler are investigated. To those functions, a different (more restrictive) limit compared to functions declared inline can be applied.
Specifies maximal overall growth of the compilation unit caused by inlining. For example, parameter value 20 limits unit growth to 1.2 times the original size. Cold functions (either marked cold via an attribute or by profile feedback) are not accounted into the unit size.
Assume that a loop with an exit will eventually take the exit and not loop indefinitely. This allows the compiler to remove loops that otherwise have no side-effects, not considering eventual endless looping as such.
Treat the specified symbol as undefined, to force linking of library modules to define it. You can use -u multiple times with different symbols to force loading of additional library modules. E.g., "-u malloc -ljemalloc" can guarantee linking the malloc() defined in the jemalloc library. Without it, the linking options order change may cause a failure to link jemalloc.
Link with libjemalloc, a fast, arena-based memory allocator.
Generate code for lp64. With ilp32, int, long int and pointer are 32-bit; with lp64, int is 32-bit, but long int and pointer are 64-bit.
Sets the language standard to the specified version, for example c18, c++17, f2008.
Sets the language standard to the specified version, for example c18, c++17, f2008.
Allow multiple definitions of the same symbols instead of failing with an error. The symbols in jemalloc may conflict with symbols in glibc when using static linking, and this flag will cause the linker to continue instead of failing.
On systems that support dynamic linking, this overrides -pie and prevents linking with the shared libraries. On other systems, this option has no effect.
Assume that the current compilation unit represents the whole program being compiled. All public functions and variables with the exception of main and those merged by attribute externally_visible become static functions and in effect are optimized more aggressively by interprocedural optimizers.
Add the specified path to the list of paths that the linker will search for archive libraries and control scripts.
Add the specified path to the list of paths that the linker will search for archive libraries and control scripts.
Add the specified path to the list of paths that the linker will search for archive libraries and control scripts.
Instruments code to collect information for profile-driven feedback. Information is collected regarding both code paths and data values.
Applies information from a profile run in order to improve optimization. Several optimizations are improved when profile data is available, including branch probabilities, loop peeling, and loop unrolling.
With -fprofile-use all portions of programs not executed during the training run are aggressively optimized for size rather than speed. In some cases it is not practical to train all possible hot paths in the program. (For example, the program may contain functions specific to some given hardware and training may not cover all hardware configurations the program is run on.) With -fprofile-partial-training profile feedback will be ignored for all functions not executed during the training run leading them to be optimized as if they were compiled without profile feedback. This leads to better performance when the training run is not representative but also leads to significantly larger generated code.
Produce debugging information.
Disregard strict standards compliance. -Ofast enables all -O3 optimizations. It also enables optimizations that are not valid for all standard-compliant programs. It turns on -ffast-math, -fallow-store-data-races (as of GCC 10), and the Fortran-specific -fstack-arrays unless -fmax-stack-var-size is specified, and -fno-protect-parens.
On aarch64 systems, -mcpu sets the kind of instructions that can be used (as if by -march) and how to tune for performance (as if by -mtune).
On x86 systems, -mcpu is a deprecated synonym for -mtune.
Enables link time optimization. When invoked with source code, it generates GIMPLE (one of GCC's internal representations) and writes it to special ELF sections in the object file. When the object files are linked together, all the function bodies are read from these ELF sections and instantiated as if they had been part of the same translation unit.
Tells the optimizer to unroll loops whose number of iterations can be determined at compile time or upon entry to the loop.
Specify growth that the early inliner can make. In effect it increases the amount of inlining for code having a large abstraction penalty.
When you use -finline-functions (included in -O3), a lot of functions that would otherwise not be considered for inlining by the compiler are investigated. To those functions, a different (more restrictive) limit compared to functions declared inline can be applied.
Specifies maximal overall growth of the compilation unit caused by inlining. For example, parameter value 20 limits unit growth to 1.2 times the original size. Cold functions (either marked cold via an attribute or by profile feedback) are not accounted into the unit size.
Specify growth that the early inliner can make. In effect it increases the amount of inlining for code having a large abstraction penalty.
When you use -finline-functions (included in -O3), a lot of functions that would otherwise not be considered for inlining by the compiler are investigated. To those functions, a different (more restrictive) limit compared to functions declared inline can be applied.
Specifies maximal overall growth of the compilation unit caused by inlining. For example, parameter value 20 limits unit growth to 1.2 times the original size. Cold functions (either marked cold via an attribute or by profile feedback) are not accounted into the unit size.
Assume that a loop with an exit will eventually take the exit and not loop indefinitely. This allows the compiler to remove loops that otherwise have no side-effects, not considering eventual endless looping as such.
Treat the specified symbol as undefined, to force linking of library modules to define it. You can use -u multiple times with different symbols to force loading of additional library modules. E.g., "-u malloc -ljemalloc" can guarantee linking the malloc() defined in the jemalloc library. Without it, the linking options order change may cause a failure to link jemalloc.
Link with libjemalloc, a fast, arena-based memory allocator.
Generate code for lp64. With ilp32, int, long int and pointer are 32-bit; with lp64, int is 32-bit, but long int and pointer are 64-bit.
Sets the language standard to the specified version, for example c18, c++17, f2008.
Sets the language standard to the specified version, for example c18, c++17, f2008.
Allow multiple definitions of the same symbols instead of failing with an error. The symbols in jemalloc may conflict with symbols in glibc when using static linking, and this flag will cause the linker to continue instead of failing.
On systems that support dynamic linking, this overrides -pie and prevents linking with the shared libraries. On other systems, this option has no effect.
Assume that the current compilation unit represents the whole program being compiled. All public functions and variables with the exception of main and those merged by attribute externally_visible become static functions and in effect are optimized more aggressively by interprocedural optimizers.
Add the specified path to the list of paths that the linker will search for archive libraries and control scripts.
Add the specified path to the list of paths that the linker will search for archive libraries and control scripts.
Add the specified path to the list of paths that the linker will search for archive libraries and control scripts.
Instruments code to collect information for profile-driven feedback. Information is collected regarding both code paths and data values.
Applies information from a profile run in order to improve optimization. Several optimizations are improved when profile data is available, including branch probabilities, loop peeling, and loop unrolling.
With -fprofile-use all portions of programs not executed during the training run are aggressively optimized for size rather than speed. In some cases it is not practical to train all possible hot paths in the program. (For example, the program may contain functions specific to some given hardware and training may not cover all hardware configurations the program is run on.) With -fprofile-partial-training profile feedback will be ignored for all functions not executed during the training run leading them to be optimized as if they were compiled without profile feedback. This leads to better performance when the training run is not representative but also leads to significantly larger generated code.
Produce debugging information.
Disregard strict standards compliance. -Ofast enables all -O3 optimizations. It also enables optimizations that are not valid for all standard-compliant programs. It turns on -ffast-math, -fallow-store-data-races (as of GCC 10), and the Fortran-specific -fstack-arrays unless -fmax-stack-var-size is specified, and -fno-protect-parens.
On aarch64 systems, -mcpu sets the kind of instructions that can be used (as if by -march) and how to tune for performance (as if by -mtune).
On x86 systems, -mcpu is a deprecated synonym for -mtune.
Enables link time optimization. When invoked with source code, it generates GIMPLE (one of GCC's internal representations) and writes it to special ELF sections in the object file. When the object files are linked together, all the function bodies are read from these ELF sections and instantiated as if they had been part of the same translation unit.
Tells the optimizer to unroll loops whose number of iterations can be determined at compile time or upon entry to the loop.
Specify growth that the early inliner can make. In effect it increases the amount of inlining for code having a large abstraction penalty.
When you use -finline-functions (included in -O3), a lot of functions that would otherwise not be considered for inlining by the compiler are investigated. To those functions, a different (more restrictive) limit compared to functions declared inline can be applied.
Specifies maximal overall growth of the compilation unit caused by inlining. For example, parameter value 20 limits unit growth to 1.2 times the original size. Cold functions (either marked cold via an attribute or by profile feedback) are not accounted into the unit size.
Specify growth that the early inliner can make. In effect it increases the amount of inlining for code having a large abstraction penalty.
When you use -finline-functions (included in -O3), a lot of functions that would otherwise not be considered for inlining by the compiler are investigated. To those functions, a different (more restrictive) limit compared to functions declared inline can be applied.
Specifies maximal overall growth of the compilation unit caused by inlining. For example, parameter value 20 limits unit growth to 1.2 times the original size. Cold functions (either marked cold via an attribute or by profile feedback) are not accounted into the unit size.
Assume that a loop with an exit will eventually take the exit and not loop indefinitely. This allows the compiler to remove loops that otherwise have no side-effects, not considering eventual endless looping as such.
Enable support for POSIX Threads. Note that C++ programs using std::thread may require this flag.
Treat the specified symbol as undefined, to force linking of library modules to define it. You can use -u multiple times with different symbols to force loading of additional library modules. E.g., "-u malloc -ljemalloc" can guarantee linking the malloc() defined in the jemalloc library. Without it, the linking options order change may cause a failure to link jemalloc.
Link with libjemalloc, a fast, arena-based memory allocator.
Inhibit all warning messages.
Write a linker map to the named file.
Write a linker map to the named file.
Inhibit all warning messages.
Write a linker map to the named file.
Inhibit all warning messages.
Write a linker map to the named file.
Write a linker map to the named file.
Inhibit all warning messages.
Write a linker map to the named file.
SPECrate runs might use one of these methods to bind processes to specific processors, depending on the config file.
Linux systems: the numactl command is commonly used. Here is a brief guide to understanding the specific command which will be found in the config file:
macOS systems: processes are not bound.
No special commands are needed for feedback-directed optimization, other than the compiler profile flags.
One or more of the following may have been used in the run. If so, it will be listed in the notes sections. Here is a brief guide to understanding them:
LD_LIBRARY_PATH=<directories> (set via config file preENV)
LD_LIBRARY_PATH controls the search order for libraries. Often, it can be defaulted. Sometimes, it is
explicitly set (as documented in the notes in the submission) in order to ensure that the correct versions of
libraries are picked up.
OMP_STACKSIZE=N (set via config file preENV)
Set the stack size for subordinate OpenMP threads.
ulimit -s N
ulimit -s unlimited
'ulimit' is a Unix command, entered prior to the run. It sets the stack size for the main process and its children,
either to N kbytes or to no limit.
MALLOC_CONF=thp:always,metadata_thp:always (set via config file preENV)
MALLOC_CONF controls jemalloc behavior.
The "thp" option controls whether heap allocations jemalloc does use transparent huge pages, if THP is supported by the operating system. The "always" setting enables transparent hugepage for all user memory mappings with MADV_HUGEPAGE; "never" ensures no transparent hugepage with MADV_NOHUGEPAGE; the default setting "default" makes no changes.
The "metadata_thp" option controls whether to allow jemalloc to use transparent huge pages (THP) for internal metadata. The "always" setting allows such usage. The "auto" setting uses no THP initially, but may begin to do so when metadata usage reaches certain level. The default is "disabled".
Note: This page provides definitions for a variety of possible settings. Please see the SPEC CPU result page to find out what settings were actually used.
Many of the settings below are defined in more detail at
https://www.kernel.org/doc/Documentation/sysctl/vm.txt
https://www.kernel.org/doc/Documentation/sysctl/kernel.txt
https://www.kernel.org/doc/Documentation/cpu-freq/governors.txt
cpupower-frequency-set Adjust the MHz for the CPUs on the system,
set limits for them, or select a "scaling governor". For example,
cpupower-frequency-set -g performance selects higher frequency
at the cost of additional power usage;
cpupower-frequency-set -g powersave does the opposite.
dirty_ratio: Sets the threshold at which processes will begin writing dirty (modified)
pages to disk. The dirty_ratio is expressed as a percentage of total available memory.
For example, this command sets the threshold to 8%
echo 8 > /proc/sys/vm/dirty_ratio
drop_caches: Reduces the size of the page cache and kernel slab objects
Example to free both:
echo 3 > /proc/sys/vm/drop_caches
numa_balancing: Automatically move memory to nodes that are accessing it.
This is done by un-mapping and re-mapping pages, which may incur unwanted overhead if proceses
are already bound to the desired memory nodes.
For example, to disable numa balancing, one could use:
echo 0 > /proc/sys/kernel/numa_balancing
numactl Controls NUMA policy for individual processes. There are many options, as defined at https://man7.org/linux/man-pages/man8/numactl.8.html. Options useful for workloads similar to SPEC CPU may include:
Note that the SPEC CPU config file may use config file preprocessing and/or
shell mathematics to compute the desired memory location or desired CPU number.
For example, these commands pick a memory unit by dividing the copy number by the number of
CPUs per node:
%define numasize 20
numactl --membind=`expr $SPECCOPYNUM / %{numasize}` --physcpubind=$SPECCOPYNUM
swappiness Controls how aggressively the kernel swaps memory pages.
The values can range from 0 to 100. Low values decrease the amount of swapping.
For example, this command indicates that swapping should occur only when essential:
echo 1 > /proc/sys/vm/swappiness
transparent_hugepage Transparent huge pages may provide a performance benefit by reducing kernel time spent looking up page locations. The potential benefit is application dependent, and some applications may do better with smaller pages.
tuned-adm Controls tuned, the dynamic adaptive system tuning daemon. Commonly, one may load a tuning profile, for example:
It is also possible to disable all profiles, using:
tuned-adm off
ulimit -s [n | unlimited]: Allow the stack size to grow to n kbytes, or unlimited to impose no limit.
zone_reclaim_mode Provides control over memory allocation when multiple NUMA nodes are active. If zone reclaim is off, data files may be cached on any node. There are three settings that can be ORed together:
For example, this command enables reclaiming:
echo 1 > /proc/sys/vm/swappiness
Dividing the chip into separate nodes (hemisphere or quadrant) may improve latency to the last level cache and main memory, which may benefit overall performance for NUMA-aware operating systems and workloads.
The jemalloc memory allocation library can speed up memory allocation, in part by keeping lists of commonly used sizes. The library includes various configuration options, which are documented at http://jemalloc.net/jemalloc.3.html and in its file INSTALL.md as found in the distribution tar file, and as posted at https://github.com/jemalloc/jemalloc/blob/master/INSTALL.md
Some of the useful options include:
Example configuration:
$ wget https://github.com/jemalloc/jemalloc/releases/download/5.3.0/jemalloc-5.3.0.tar.bz2 $ bzip2 -dc jemalloc-5.3.0.tar.bz2 | tar -xf - $ cd jemalloc-5.3.0/ $ ./configure --prefix=/usr/local/jemalloc-530 $ make -j30 $ sudo make install
Flag description origin markings:
|
Indicates that the flag description came from the user flags file. |
![[suite]](https://www.spec.org/auto/cpu2026/images/suite.png) |
Indicates that the flag description came from the suite-wide flags file. |
![[benchmark]](https://www.spec.org/auto/cpu2026/images/benchmark.png) |
Indicates that the flag description came from a per-benchmark flags file. |
For questions about the meanings of these flags, please contact the tester.
For other inquiries, please contact info@spec.org
Copyright 2026 Standard Performance Evaluation Corporation
Tested with SPEC CPU®2026 v0.902.0.
Report generated on 2026-05-04 23:26:57 by SPEC CPU®2026 flags formatter (5b352a85).