neulab/tldr huggingface dataset:
When used in combination with the -x command line option, -save-temps is sensible enough to avoid over writing an input source file with the same extension as an intermediate file.  The corresponding intermediate file may be obtained by renaming the source file before using -save-temps.
-mllvm string This option provides a way to supply llvm optimization and code generation debugging options to LLVM component directly. This option is intended for compiler developers, who are investigating LLVM bugs, not end users.
-time Report the CPU time taken by each subprocess in the compilation sequence.  For C source files, this is the compiler proper and assembler (plus the linker if linking is done).  The output looks like this:
It is enabled by default when compiling with optimization (-Os, -O, -O2, -Oz (APPLE ONLY), ...), debugging information (-g) and the debug info format supports it.
-print-multi-lib Print the mapping from multilib directory names to compiler switches that enable them.  The directory name is separated from the switches by ;, and each switch starts with an @} instead of the @samp{-, without spaces between multiple switches.  This is supposed to ease shell-processing.
This is useful when you use -nostdlib or -nodefaultlibs but you do want to link with libgcc.a.  You can do
-print-search-dirs Print the name of the configured installation directory and a list of program and library directories gcc will search---and don't do anything else.
-dumpversion Print the compiler version (for example, 3.0)---and don't do anything else.
-feliminate-unused-debug-types Normally, when producing DWARF2 output, GCC will emit debugging information for all types declared in a compilation unit, regardless of whether or not they are actually used in that compilation unit. Sometimes this is useful, such as if, in the debugger, you want to cast a value to a type that is not actually used in your program (but is declared).  More often, however, this results in a significant amount of wasted space.  With this option, GCC will avoid producing debug symbol output for types that are nowhere used in the source file being compiled.
Without any optimization option, the compiler's goal is to reduce the cost of compilation and to make debugging produce the expected results. Statements are independent: if you stop the program with a breakpoint between statements, you can then assign a new value to any variable or change the program counter to any other statement in the function and get exactly the results you would expect from the source code.
The compiler performs optimization based on the knowledge it has of the program.  Optimization levels -O and above, in particular, enable unit- at-a-time mode, which allows the compiler to consider information gained from later functions in the file when compiling a function.  Compiling multiple files at once to a single output file in unit-at-a-time mode allows the compiler to use information gained from all of the files when compiling each of them.
Not all optimizations are controlled directly by a flag.  Only optimizations that have a flag are listed.
-O turns on the following optimization flags: -fdefer-pop -fdelayed-branch -fguess-branch-probability -fcprop-registers -fif-conversion -fif-conversion2 -ftree-ccp -ftree-dce -ftree-dominator-opts -ftree-dse -ftree-ter -ftree-lrs -ftree-sra -ftree-copyrename -ftree-fre -ftree-ch -funit-at-a-time -fmerge-constants
-O also turns on -fomit-frame-pointer on machines where doing so does not interfere with debugging.
-O2 Optimize even more.  GCC performs nearly all supported optimizations that do not involve a space-speed tradeoff.  The compiler does not perform loop unrolling or function inlining when you specify -O2.  As compared to -O, this option increases both compilation time and the performance of the generated code.
-O2 turns on all optimization flags specified by -O.  It also turns on the following optimization flags: -fthread-jumps -fcrossjumping -foptimize-sibling-calls -fcse-follow-jumps  -fcse-skip-blocks -fgcse -fgcse-lm -fexpensive-optimizations -frerun-cse-after-loop -fcaller-saves -fpeephole2 -fschedule-insns  -fschedule-insns2 -fsched-interblock  -fsched-spec -fregmove -fstrict-aliasing -fstrict-overflow -fdelete-null-pointer-checks -freorder-blocks -freorder-functions -falign-functions  -falign-jumps -falign-loops -falign-labels -ftree-vrp -ftree-pre
-O2 doesn't turn on -ftree-vrp for the Ada compiler.  This option must be explicitly specified on the command line to be enabled for the Ada compiler.
In Apple's version of GCC, -fstrict-aliasing, -freorder-blocks, and -fsched-interblock are disabled by default when optimizing.
-O3 Optimize yet more.  -O3 turns on all optimizations specified by -O2 and also turns on the -finline-functions, -funswitch-loops and -fgcse-after-reload options.
-flto Enable LLVM Link Time Optimization.
-O4 Enable LLVM Link Time Optimization. -O4 turns on all LLVM compile time optimizations specified by -O2.
-O0 Do not optimize.  This is the default.
-fast Optimize for maximum performance. -fast changes the overall optimization strategy of GCC in order to produce the fastest possible running code for PPC7450 and G5 architectures. By default, -fast optimizes for G5. Programs optimized for G5 will not run on PPC7450. To optimize for PPC7450, add -mcpu=7450 on command line.
-fast currently enables the following optimization flags (for G5 and PPC7450).  These flags may change in the future.  You cannot override any of these options if you use -fast except by setting -mcpu=7450 (or -fPIC, see below).
-O3 -falign-loops-max-skip=15 -falign-jumps-max-skip=15 -falign-loops=16 -falign-jumps=16 -falign-functions=16 -malign-natural (except when -fastf is specified) -ffast-math -fstrict-aliasing -funroll-loops -ftree-loop-linear -ftree-loop-memset -mcpu=G5 -mpowerpc-gpopt -mtune=G5  (unless -mtune=G4 is specified).  -fsched-interblock -fgcse-sm -mpowerpc64
To build shared libraries with -fast, specify -fPIC on the command line as -fast turns on -mdynamic-no-pic otherwise.
Important notes: -ffast-math results in code that is not necessarily IEEE-compliant.  -fstrict-aliasing is highly likely to break non- standard-compliant programs.  -malign-natural only works properly if the entire program is compiled with it, and none of the standard headers/libraries contain any code that changes alignment when this option is used.
On Intel target, -fast currently enables the following optimization flags:
-O3 -fomit-frame-pointer -fstrict-aliasing -momit-leaf-frame-pointer -fno-tree-pre -falign-loops
All choices of flags enabled by -fast are subject to change without notice.
-Os Optimize for size, but not at the expense of speed.  -Os enables all -O2 optimizations that do not typically increase code size.  However, instructions are chosen for best performance, regardless of size.  To optimize solely for size on Darwin, use -Oz (APPLE ONLY).
The following options are set for -O2, but are disabled under -Os: -falign-functions  -falign-jumps  -falign-loops -falign-labels -freorder-blocks  -freorder-blocks-and-partition -fprefetch-loop-arrays  -ftree-vect-loop-version
When optimizing with -Os or -Oz (APPLE ONLY) on Darwin, any function up to 30 "estimated insns" in size will be considered for inlining. When compiling C and Objective-C sourcefiles with -Os or -Oz on Darwin, functions explictly marked with the "inline" keyword up to 450 "estimated insns" in size will be considered for inlining.  When compiling for Apple POWERPC targets, -Os and -Oz (APPLE ONLY) disable use of the string instructions even though they would usually be smaller, because the kernel can't emulate them correctly in some rare cases.  This behavior is not portable to any other gcc environment, and will not affect most programs at all.  If you really want the string instructions, use -mstring.
-Oz (APPLE ONLY) Optimize for size, regardless of performance.  -Oz enables the same optimization flags that -Os uses, but -Oz also enables other optimizations intended solely to reduce code size.  In particular, instructions that encode into fewer bytes are preferred over longer instructions that execute in fewer cycles.  -Oz on Darwin is very similar to -Os in FSF distributions of GCC.  -Oz employs the same inlining limits and avoids string instructions just like -Os.
Options of the form -fflag specify machine-independent flags.  Most flags have both positive and negative forms; the negative form of -ffoo would be -fno-foo.  In the table below, only one of the forms is listed---the one you typically will use.  You can figure out the other form by either removing no- or adding it.
-fno-default-inline Do not make member functions inline by default merely because they are defined inside the class scope (C++ only).  Otherwise, when you specify -O, member functions defined inside class scope are compiled inline by default; i.e., you don't need to add inline in front of the member function name.
-fno-defer-pop Always pop the arguments to each function call as soon as that function returns.  For machines which 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.
Disabled at levels -O, -O2, -O3, -Os, -Oz (APPLE ONLY).
-fforce-mem Force memory operands to be copied into registers before doing arithmetic on them.  This produces better code by making all memory references potential common subexpressions.  When they are not common subexpressions, instruction combination should eliminate the separate register-load. This option is now a nop and will be removed in 4.3.
-fforce-addr Force memory address constants to be copied into registers before doing arithmetic on them.
-fomit-frame-pointer Don't keep the frame pointer in a register for functions that don't need one.  This avoids the instructions to save, set up and restore frame pointers; it also makes an extra register available in many functions.  It also makes debugging impossible on some machines.
On some machines, such as the VAX, this flag has no effect, because the standard calling sequence automatically handles the frame pointer and nothing is saved by pretending it doesn't exist.  The machine- description macro "FRAME_POINTER_REQUIRED" controls whether a target machine supports this flag.
Enabled at levels -O, -O2, -O3, -Os, -Oz (APPLE ONLY).
Enabled at levels -O2, -O3, -Os, -Oz (APPLE ONLY).
-fno-inline Don't pay attention to the "inline" keyword.  Normally this option is used to keep the compiler from expanding any functions inline.  Note that if you are not optimizing, no functions can be expanded inline.
-finline-functions Integrate all simple functions into their callers.  The compiler heuristically decides which functions are simple enough to be worth integrating in this way.
Enabled at level -O3.
Enabled if -funit-at-a-time is enabled.
-finline-limit=n By default, GCC limits the size of functions that can be inlined. This flag allows the control of this limit for functions that are explicitly marked as inline (i.e., marked with the inline keyword or defined within the class definition in c++).  n is the size of functions that can be inlined in number of pseudo instructions (not counting parameter handling).  The default value of n is 600. Increasing this value can result in more inlined code at the cost of compilation time and memory consumption.  Decreasing usually makes the compilation faster and less code will be inlined (which presumably means slower programs).  This option is particularly useful for programs that use inlining heavily such as those based on recursive templates with C++.
max-inline-insns-single is set to I<n>/2.
max-inline-insns-auto is set to I<n>/2.
min-inline-insns is set to 130 or I<n>/4, whichever is smaller.
max-inline-insns-rtl is set to I<n>.
See below for a documentation of the individual parameters controlling inlining.
Note: pseudo instruction represents, in this particular context, an abstract measurement of function's size.  In no way does it represent a count of assembly instructions and as such its exact meaning might change from one release to an another.  This option has no effect in llvm-gcc.  The always_inline and noinline parameters are honored, but none of the other inlining parameters have any effect; there is no specific user control on the amount of inlining done.  The compiler will do less inlining at -O2 or -Os than at -O3.
-fkeep-inline-functions In C, emit "static" functions that are declared "inline" into the object file, even if the function has been inlined into all of its callers.  This switch does not affect functions using the "extern inline" extension in GNU C.  In C++, emit any and all inline functions into the object file.
GCC enables this option by default.  If you want to force the compiler to check if the variable was referenced, regardless of whether or not optimization is turned on, use the -fno-keep-static-consts option.
-flocal-alloc (APPLE ONLY) Enable the local (intra-basic-block) register allocator.
GCC enables this option by default.  If you want to force the compiler to supress register allocation within a basic block, use the -fno-local-alloc option.  This option cannot be disabled with -O0, for correctness reasons.
-fmerge-constants Attempt to merge identical constants (string constants and floating point constants) across compilation units.
This option implies -fmerge-constants.  In addition to -fmerge-constants this considers e.g. even constant initialized arrays or initialized constant variables with integral or floating point types.  Languages like C or C++ require each non-automatic variable to have distinct location, so using this option will result in non-conforming behavior.
-fno-branch-count-reg Do not use "decrement and branch" instructions on a count register, but instead generate a sequence of instructions that decrement a register, compare it against zero, then branch based upon the result. This option is only meaningful on architectures that support such instructions, which include x86, PowerPC, IA-64 and S/390.
The default is -fbranch-count-reg.
This option turns off this behavior because some programs explicitly rely on variables going to the data section.  E.g., so that the resulting executable can find the beginning of that section and/or make assumptions based on that.
-fbounds-check For front-ends that support it, generate additional code to check that indices used to access arrays are within the declared range. This is currently only supported by the Java and Fortran front-ends, where this option defaults to true and false respectively.
-fmudflap -fmudflapth -fmudflapir For front-ends that support it (C and C++), instrument all risky pointer/array dereferencing operations, some standard library string/heap functions, and some other associated constructs with range/validity tests.  Modules so instrumented should be immune to buffer overflows, invalid heap use, and some other classes of C/C++ programming errors.  The instrumentation relies on a separate runtime library (libmudflap), which will be linked into a program if -fmudflap is given at link time.  Run-time behavior of the instrumented program is controlled by the MUDFLAP_OPTIONS environment variable.  See "env MUDFLAP_OPTIONS=-help a.out" for its options.
Use -fmudflapth instead of -fmudflap to compile and to link if your program is multi-threaded.  Use -fmudflapir, in addition to -fmudflap or -fmudflapth, if instrumentation should ignore pointer reads.  This produces less instrumentation (and therefore faster execution) and still provides some protection against outright memory corrupting writes, but allows erroneously read data to propagate within a program.
-fthread-jumps Perform optimizations where we check to see if a jump branches to a location where another comparison subsumed by the first is found.  If so, the first branch is redirected to either the destination of the second branch or a point immediately following it, depending on whether the condition is known to be true or false.
-fcse-follow-jumps In common subexpression elimination, scan through jump instructions when the target of the jump is not reached by any other path.  For example, when CSE encounters an "if" statement with an "else" clause, CSE will follow the jump when the condition tested is false.
-fcse-skip-blocks This is similar to -fcse-follow-jumps, but causes CSE to follow jumps which conditionally skip over blocks.  When CSE encounters a simple "if" statement with no else clause, -fcse-skip-blocks causes CSE to follow the jump around the body of the "if".
-frerun-cse-after-loop Re-run common subexpression elimination after loop optimizations has been performed.
Note: When compiling a program using computed gotos, a GCC extension, you may get better runtime performance if you disable the global common subexpression elimination pass by adding -fno-gcse to the command line.
-fgcse-lm When -fgcse-lm is enabled, global common subexpression elimination will attempt to move loads which are only killed by stores into themselves.  This allows a loop containing a load/store sequence to be changed to a load outside the loop, and a copy/store within the loop.
Enabled by default when gcse is enabled.
-fgcse-sm When -fgcse-sm is enabled, a store motion pass is run after global common subexpression elimination.  This pass will attempt to move stores out of loops.  When used in conjunction with -fgcse-lm, loops containing a load/store sequence can be changed to a load before the loop and a store after the loop.
-fgcse-after-reload When -fgcse-after-reload is enabled, a redundant load elimination pass is performed after reload.  The purpose of this pass is to cleanup redundant spilling.
-funsafe-loop-optimizations If given, the loop optimizer will assume that loop indices do not overflow, and that the loops with nontrivial exit condition are not infinite.  This enables a wider range of loop optimizations even if the loop optimizer itself cannot prove that these assumptions are valid.  Using -Wunsafe-loop-optimizations, the compiler will warn you if it finds this kind of loop.
-fcrossjumping Perform cross-jumping transformation.  This transformation unifies equivalent code and save code size.  The resulting code may or may not perform better than without cross-jumping.
-fif-conversion Attempt to transform conditional jumps into branch-less equivalents. This include use of conditional moves, min, max, set flags and abs instructions, and some tricks doable by standard arithmetics.  The use of conditional execution on chips where it is available is controlled by "if-conversion2".
-fdelete-null-pointer-checks Use global dataflow analysis to identify and eliminate useless checks for null pointers.  The compiler assumes that dereferencing a null pointer would have halted the program.  If a pointer is checked after it has already been dereferenced, it cannot be null.
In some environments, this assumption is not true, and programs can safely dereference null pointers.  Use -fno-delete-null-pointer-checks to disable this optimization for programs which depend on that behavior.
-foptimize-register-move -fregmove Attempt to reassign register numbers in move instructions and as operands of other simple instructions in order to maximize the amount of register tying.  This is especially helpful on machines with two- operand instructions.
Note -fregmove and -foptimize-register-move are the same optimization.
-fschedule-insns If supported for the target machine, attempt to reorder instructions to eliminate execution stalls due to required data being unavailable. This helps machines that have slow floating point or memory load instructions by allowing other instructions to be issued until the result of the load or floating point instruction is required.
Enabled at levels -O2, -O3, -Os, -Oz for PPC targets; ignored for x86 targets (APPLE ONLY).
-fno-sched-interblock Don't schedule instructions across basic blocks.  This is normally enabled by default when scheduling before register allocation, i.e. with -fschedule-insns or at -O2 or higher.
-fno-sched-spec Don't allow speculative motion of non-load instructions.  This is normally enabled by default when scheduling before register allocation, i.e.  with -fschedule-insns or at -O2 or higher.
-fsched-stalled-insns=n Define how many insns (if any) can be moved prematurely from the queue of stalled insns into the ready list, during the second scheduling pass.
-fsched-stalled-insns-dep=n Define how many insn groups (cycles) will be examined for a dependency on a stalled insn that is candidate for premature removal from the queue of stalled insns.  Has an effect only during the second scheduling pass, and only if -fsched-stalled-insns is used and its value is not zero.
-fsched2-use-superblocks When scheduling after register allocation, do use superblock scheduling algorithm.  Superblock scheduling allows motion across basic block boundaries resulting on faster schedules.  This option is experimental, as not all machine descriptions used by GCC model the CPU closely enough to avoid unreliable results from the algorithm.
-fsched2-use-traces Use -fsched2-use-superblocks algorithm when scheduling after register allocation and additionally perform code duplication in order to increase the size of superblocks using tracer pass.  See -ftracer for details on trace formation.
This mode should produce faster but significantly longer programs. Also without -fbranch-probabilities the traces constructed may not match the reality and hurt the performance.  This only makes sense when scheduling after register allocation, i.e. with -fschedule-insns2 or at -O2 or higher.
-fsee Eliminates redundant extension instructions and move the non redundant ones to optimal placement using LCM.
-freschedule-modulo-scheduled-loops The modulo scheduling comes before the traditional scheduling, if a loop was modulo scheduled we may want to prevent the later scheduling passes from changing its schedule, we use this option to control that.
-fcaller-saves Enable values to be allocated in registers that will be clobbered by function calls, by emitting extra instructions to save and restore the registers around such calls.  Such allocation is done only when it seems to result in better code than would otherwise be produced.
-ftree-pre Perform Partial Redundancy Elimination (PRE) on trees.  This flag is enabled by default at -O2 and -O3.
-ftree-fre Perform Full Redundancy Elimination (FRE) on trees.  The difference between FRE and PRE is that FRE only considers expressions that are computed on all paths leading to the redundant computation.  This analysis faster than PRE, though it exposes fewer redundancies.  This flag is enabled by default at -O and higher.
-ftree-store-copy-prop Perform copy propagation of memory loads and stores.  This pass eliminates unnecessary copy operations in memory references (structures, global variables, arrays, etc).  This flag is enabled by default at -O2 and higher.
-ftree-salias Perform structural alias analysis on trees.  This flag is enabled by default at -O and higher.
-fipa-pta Perform interprocedural pointer analysis.
-ftree-sink Perform forward store motion  on trees.  This flag is enabled by default at -O and higher.
-ftree-store-ccp Perform sparse conditional constant propagation (CCP) on trees.  This pass operates on both local scalar variables and memory stores and loads (global variables, structures, arrays, etc).  This flag is enabled by default at -O2 and higher.
-ftree-ch Perform loop header copying on trees.  This is beneficial since it increases effectiveness of code motion optimizations.  It also saves one jump.  This flag is enabled by default at -O and higher.  It is not enabled for -Os or -Oz (APPLE ONLY), since it usually increases code size.
-ftree-loop-linear Perform linear loop transformations on tree.  This flag can improve cache performance and allow further loop optimizations to take place. This flag is known to have bugs that cause incorrect code to be generated in some rare cases. Note this flag is included in -fast.
-ftree-loop-im Perform loop invariant motion on trees.  This pass moves only invariants that would be hard to handle at RTL level (function calls, operations that expand to nontrivial sequences of insns).  With -funswitch-loops it also moves operands of conditions that are invariant out of the loop, so that we can use just trivial invariantness analysis in loop unswitching.  The pass also includes store motion.
-ftree-loop-ivcanon Create a canonical counter for number of iterations in the loop for that determining number of iterations requires complicated analysis. Later optimizations then may determine the number easily.  Useful especially in connection with unrolling.
-ftree-sra Perform scalar replacement of aggregates.  This pass replaces structure references with scalars to prevent committing structures to memory too early.  This flag is enabled by default at -O and higher.
-ftree-copyrename Perform copy renaming on trees.  This pass attempts to rename compiler temporaries to other variables at copy locations, usually resulting in variable names which more closely resemble the original variables.  This flag is enabled by default at -O and higher.
-ftree-lrs Perform live range splitting during the SSA->normal phase.  Distinct live ranges of a variable are split into unique variables, allowing for better optimization later.  This is enabled by default at -O and higher.
-ftree-vectorize Perform loop vectorization on trees.
In Apple's version of GCC, -fstrict-aliasing is enabled by default when loop vectorization is enabled. See -fstrict-aliasing document for more information.
-ftree-vect-loop-version Perform loop versioning when doing loop vectorization on trees.  When a loop appears to be vectorizable except that data alignment or data dependence cannot be determined at compile time then vectorized and non-vectorized versions of the loop are generated along with runtime checks for alignment or dependence to control which version is executed.  This option is enabled by default except at level -Os where it is disabled.
-ftracer Perform tail duplication to enlarge superblock size.  This transformation simplifies the control flow of the function allowing other optimizations to do better job.
-funroll-loops Unroll loops whose number of iterations can be determined at compile time or upon entry to the loop.  -funroll-loops implies -frerun-cse-after-loop.  This option makes code larger, and may or may not make it run faster.
-funroll-all-loops Unroll all loops, even if their number of iterations is uncertain when the loop is entered.  This usually makes programs run more slowly.  -funroll-all-loops implies the same options as -funroll-loops,
-fsplit-ivs-in-unroller Enables expressing of values of induction variables in later iterations of the unrolled loop using the value in the first iteration.  This breaks long dependency chains, thus improving efficiency of the scheduling passes.
Combination of -fweb and CSE is often sufficient to obtain the same effect.  However in cases the loop body is more complicated than a single basic block, this is not reliable.  It also does not work at all on some of the architectures due to restrictions in the CSE pass.
-fvariable-expansion-in-unroller With this option, the compiler will create multiple copies of some local variables when unrolling a loop which can result in superior code.
Disabled at levels -Os and -Oz (APPLE ONLY).
-fpeephole is enabled by default.  -fpeephole2 enabled at levels -O2, -O3, -Os, -Oz (APPLE ONLY).
GCC will use heuristics to guess branch probabilities if they are not provided by profiling feedback (-fprofile-arcs).  These heuristics are based on the control flow graph.  If some branch probabilities are specified by __builtin_expect, then the heuristics will be used to guess branch probabilities for the rest of the control flow graph, taking the __builtin_expect info into account.  The interactions between the heuristics and __builtin_expect can be complex, and in some cases, it may be useful to disable the heuristics so that the effects of __builtin_expect are easier to understand.
The default is -fguess-branch-probability at levels -O, -O2, -O3, -Os, -Oz (APPLE ONLY).
This optimization is automatically turned off in the presence of exception handling, for linkonce sections, for functions with a user- defined section attribute and on any architecture that does not support named sections.
Also profile feedback must be available in to make this option effective.  See -fprofile-arcs for details.
-fstrict-aliasing Allows the compiler to assume the strictest aliasing rules applicable to the language being compiled.  For C (and C++), this activates optimizations based on the type of expressions.  In particular, an object of one type is assumed never to reside at the same address as an object of a different type, unless the types are almost the same. For example, an "unsigned int" can alias an "int", but not a "void*" or a "double".  A character type may alias any other type.
int f() { a_union t; t.d = 3.0; return t.i; }
The practice of reading from a different union member than the one most recently written to (called "type-punning") is common.  Even with -fstrict-aliasing, type-punning is allowed, provided the memory is accessed through the union type.  So, the code above will work as expected.  However, this code might not:
int f() { a_union t; int* ip; t.d = 3.0; ip = &t.i; return *ip; }
Every language that wishes to perform language-specific alias analysis should define a function that computes, given an "tree" node, an alias set for the node.  Nodes in different alias sets are not allowed to alias.  For an example, see the C front-end function "c_get_alias_set".
-fstrict-overflow Allow the compiler to assume strict signed overflow rules, depending on the language being compiled.  For C (and C++) this means that overflow when doing arithmetic with signed numbers is undefined, which means that the compiler may assume that it will not happen. This permits various optimizations.  For example, the compiler will assume that an expression like "i + 10 > i" will always be true for signed "i".  This assumption is only valid if signed overflow is undefined, as the expression is false if "i + 10" overflows when using twos complement arithmetic.  When this option is in effect any attempt to determine whether an operation on signed numbers will overflow must be written carefully to not actually involve overflow.
See also the -fwrapv option.  Using -fwrapv means that signed overflow is fully defined: it wraps.  When -fwrapv is used, there is no difference between -fstrict-overflow and -fno-strict-overflow. With -fwrapv certain types of overflow are permitted.  For example, if the compiler gets an overflow when doing arithmetic on constants, the overflowed value can still be used with -fwrapv, but not otherwise.
The -fstrict-overflow option is enabled at levels -O2, -O3, -Os.
-falign-functions -falign-functions=n Align the start of functions to the next power-of-two greater than n, skipping up to n bytes.  For instance, -falign-functions=32 aligns functions to the next 32-byte boundary, but -falign-functions=24 would align to the next 32-byte boundary only if this can be done by skipping 23 bytes or less.
-fno-align-functions and -falign-functions=1 are equivalent and mean that functions will not be aligned.
-falign-labels -falign-labels=n Align all branch targets to a power-of-two boundary, skipping up to n bytes like -falign-functions.  This option can easily make code slower, because it must insert dummy operations for when the branch target is reached in the usual flow of the code.
-fno-align-labels and -falign-labels=1 are equivalent and mean that labels will not be aligned.
If n is not specified or is zero, use a machine-dependent default which is very likely to be 1, meaning no alignment.
-falign-loops-max-skip -falign-loops-max-skip=n Align loops to a power-of-two boundary, but do not skip more than n bytes to do so.
-falign-loops -falign-loops=n Align loops to a power-of-two boundary, skipping up to n bytes like -falign-functions.  The hope is that the loop will be executed many times, which will make up for any execution of the dummy operations.
-fno-align-loops and -falign-loops=1 are equivalent and mean that loops will not be aligned.
-falign-jumps -falign-jumps=n Align branch targets to a power-of-two boundary, for branch targets where the targets can only be reached by jumping, skipping up to n bytes like -falign-functions.  In this case, no dummy operations need be executed.
-falign-jumps-max-skip -falign-jumps-max-skip=n Align branch targets to a power-of-two boundary, but do not skip more than n bytes to do so.
-fno-align-jumps and -falign-jumps=1 are equivalent and mean that loops will not be aligned.
-funit-at-a-time Parse the whole compilation unit before starting to produce code. This allows some extra optimizations to take place but consumes more memory (in general).  There are some compatibility issues with unit- at-a-time mode:
•   enabling unit-at-a-time mode may change the order in which functions, variables, and top-level "asm" statements are emitted, and will likely break code relying on some particular ordering. The majority of such top-level "asm" statements, though, can be replaced by "section" attributes.  The fno-toplevel-reorder option may be used to keep the ordering used in the input file, at the cost of some optimizations.
•   unit-at-a-time mode removes unreferenced static variables and functions.  This may result in undefined references when an "asm" statement refers directly to variables or functions that are otherwise unused.  In that case either the variable/function shall be listed as an operand of the "asm" statement operand or, in the case of top-level "asm" statements the attribute "used" shall be used on the declaration.
•   Static functions now can use non-standard passing conventions that may break "asm" statements calling functions directly. Again, attribute "used" will prevent this behavior.
As a temporary workaround, -fno-unit-at-a-time can be used, but this scheme may not be supported by future releases of GCC.
-fno-toplevel-reorder Do not reorder top-level functions, variables, and "asm" statements. Output them in the same order that they appear in the input file. When this option is used, unreferenced static variables will not be removed.  This option is intended to support existing code which relies on a particular ordering.  For new code, it is better to use attributes.
-fweb Constructs webs as commonly used for register allocation purposes and assign each web individual pseudo register.  This allows the register allocation pass to operate on pseudos directly, but also strengthens several other optimization passes, such as CSE, loop optimizer and trivial dead code remover.  It can, however, make debugging impossible, since variables will no longer stay in a "home register".
-fwhole-program Assume that the current compilation unit represents 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 a affect gets more aggressively optimized by interprocedural optimizers.  While this option is equivalent to proper use of "static" keyword for programs consisting of single file, in combination with option --combine this flag can be used to compile most of smaller scale C programs since the functions and variables become local for the whole combined compilation unit, not for the single source file itself.
-fno-cprop-registers After register allocation and post-register allocation instruction splitting, we perform a copy-propagation pass to try to reduce scheduling dependencies and occasionally eliminate the copy.
-fprofile-generate Enable options usually used for instrumenting application to produce profile useful for later recompilation with profile feedback based optimization.  You must use -fprofile-generate both when compiling and when linking your program.
The following options are enabled: "-fprofile-arcs", "-fprofile-values", "-fvpt".
-fprofile-use Enable profile feedback directed optimizations, and optimizations generally profitable only with profile feedback available.
The following options are enabled: "-fbranch-probabilities", "-fvpt", "-funroll-loops", "-fpeel-loops", "-ftracer"
The following options control compiler behavior regarding floating point arithmetic.  These options trade off between speed and correctness.  All must be specifically enabled.
-ffloat-store Do not store floating point variables in registers, and inhibit other options that might change whether a floating point value is taken from a register or memory.
-ffast-math Sets -fno-math-errno, -funsafe-math-optimizations, -fno-trapping-math, -ffinite-math-only, -fno-rounding-math, -fno-signaling-nans and fcx-limited-range.
This option should never be turned on by any -O option since it can result in incorrect output for programs which depend on an exact implementation of IEEE or ISO rules/specifications for math functions.
-fno-math-errno Do not set ERRNO after calling math functions that are executed with a single instruction, e.g., sqrt.  A program that relies on IEEE exceptions for math error handling may want to use this flag for speed while maintaining IEEE arithmetic compatibility.
(APPLE ONLY) The Darwin math libraries never set errno, so there is no point in having the compiler generate code that assumes they might.  Therefore, the default is -fno-math-errno on Darwin.
-funsafe-math-optimizations Allow optimizations for floating-point arithmetic that (a) assume that arguments and results are valid and (b) may violate IEEE or ANSI standards.  When used at link-time, it may include libraries or startup files that change the default FPU control word or other similar optimizations.
This option should never be turned on by any -O option since it can result in incorrect output for programs which depend on an exact implementation of IEEE or ISO rules/specifications.
-fno-trapping-math Compile code assuming that floating-point operations cannot generate user-visible traps.  These traps include division by zero, overflow, underflow, inexact result and invalid operation.  This option implies -fno-signaling-nans.  Setting this option may allow faster code if one relies on "non-stop" IEEE arithmetic, for example.
-frounding-math Disable transformations and optimizations that assume default floating point rounding behavior.  This is round-to-zero for all floating point to integer conversions, and round-to-nearest for all other arithmetic truncations.  This option should be specified for programs that change the FP rounding mode dynamically, or that may be executed with a non-default rounding mode.  This option disables constant folding of floating point expressions at compile-time (which may be affected by rounding mode) and arithmetic transformations that are unsafe in the presence of sign-dependent rounding modes.
This option is experimental and does not currently guarantee to disable all GCC optimizations that are affected by rounding mode. Future versions of GCC may provide finer control of this setting using C99's "FENV_ACCESS" pragma.  This command line option will be used to specify the default state for "FENV_ACCESS".
-frtl-abstract-sequences It is a size optimization method. This option is to find identical sequences of code, which can be turned into pseudo-procedures  and then  replace  all  occurrences with  calls to  the  newly created subroutine. It is kind of an opposite of -finline-functions.  This optimization runs at RTL level.
-fsingle-precision-constant Treat floating point constant as single precision constant instead of implicitly converting it to double precision constant.
-fcx-limited-range -fno-cx-limited-range When enabled, this option states that a range reduction step is not needed when performing complex division.  The default is -fno-cx-limited-range, but is enabled by -ffast-math.
-fbranch-probabilities After running a program compiled with -fprofile-arcs, you can compile it a second time using -fbranch-probabilities, to improve optimizations based on the number of times each branch was taken. When the program compiled with -fprofile-arcs exits it saves arc execution counts to a file called sourcename.gcda for each source file  The information in this data file is very dependent on the structure of the generated code, so you must use the same source code and the same optimization options for both compilations.
With -fbranch-probabilities, GCC puts a REG_BR_PROB note on each JUMP_INSN and CALL_INSN.  These can be used to improve optimization. Currently, they are only used in one place: in reorg.c, instead of guessing which path a branch is mostly to take, the REG_BR_PROB values are used to exactly determine which path is taken more often.
With -fbranch-probabilities, it reads back the data gathered from profiling values of expressions and adds REG_VALUE_PROFILE notes to instructions for their later usage in optimizations.
Enabled with -fprofile-generate and -fprofile-use.
-fvpt If combined with -fprofile-arcs, it instructs the compiler to add a code to gather information about values of expressions.
With -fbranch-probabilities, it reads back the data gathered and actually performs the optimizations based on them.  Currently the optimizations include specialization of division operation using the knowledge about the value of the denominator.
-frename-registers Attempt to avoid false dependencies in scheduled code by making use of registers left over after register allocation.  This optimization will most benefit processors with lots of registers.  Depending on the debug information format adopted by the target, however, it can make debugging impossible, since variables will no longer stay in a "home register".
-funroll-loops Unroll loops whose number of iterations can be determined at compile time or upon entry to the loop.  -funroll-loops implies -frerun-cse-after-loop, -fweb and -frename-registers.  It also turns on complete loop peeling (i.e. complete removal of loops with small constant number of iterations).  This option makes code larger, and may or may not make it run faster.
-fpeel-loops Peels the loops for that there is enough information that they do not roll much (from profile feedback).  It also turns on complete loop peeling (i.e. complete removal of loops with small constant number of iterations).
-fmove-loop-invariants Enables the loop invariant motion pass in the RTL loop optimizer. Enabled at level -O1
Use these options on systems where the linker can perform optimizations to improve locality of reference in the instruction space.  Most systems using the ELF object format and SPARC processors running Solaris 2 have linkers with such optimizations.  AIX may have these optimizations in the future.
Only use these options when there are significant benefits from doing so.  When you specify these options, the assembler and linker will create larger object and executable files and will also be slower. You will not be able to use "gprof" on all systems if you specify this option and you may have problems with debugging if you specify both this option and -g.
-fbranch-target-load-optimize Perform branch target register load optimization before prologue / epilogue threading.  The use of target registers can typically be exposed only during reload, thus hoisting loads out of loops and doing inter-block scheduling needs a separate optimization pass.
-fbranch-target-load-optimize2 Perform branch target register load optimization after prologue / epilogue threading.
-fbtr-bb-exclusive When performing branch target register load optimization, don't reuse branch target registers in within any basic block.
-fstack-protector Emit extra code to check for buffer overflows, such as stack smashing attacks.  This is done by adding a guard variable to functions with vulnerable objects.  This includes functions that call alloca, and functions with buffers larger than 8 bytes.  The guards are initialized when a function is entered and then checked when the function exits.  If a guard check fails, an error message is printed and the program exits.
would usually calculate the addresses of all three variables, but if you compile it with -fsection-anchors, it will access the variables from a common anchor point instead.  The effect is similar to the following pseudocode (which isn't valid C):
--param name=value In some places, GCC uses various constants to control the amount of optimization that is done.  For example, GCC will not inline functions that contain more that a certain number of instructions. You can control some of these constants on the command-line using the --param option.
In each case, the value is an integer.  The allowable choices for name are given in the following table:
salias-max-implicit-fields The maximum number of fields in a variable without direct structure accesses for which structure aliasing will consider trying to track each field.  The default is 5
salias-max-array-elements The maximum number of elements an array can have and its elements still be tracked individually by structure aliasing. The default is 4
sra-max-structure-size The maximum structure size, in bytes, at which the scalar replacement of aggregates (SRA) optimization will perform block copies.  The default value, 0, implies that GCC will select the most appropriate size itself.
sra-field-structure-ratio The threshold ratio (as a percentage) between instantiated fields and the complete structure size.  We say that if the ratio of the number of bytes in instantiated fields to the number of bytes in the complete structure exceeds this parameter, then block copies are not used.  The default is 75.
max-crossjump-edges The maximum number of incoming edges to consider for crossjumping.  The algorithm used by -fcrossjumping is O(N^2) in the number of edges incoming to each block.  Increasing values mean more aggressive optimization, making the compile time increase with probably small improvement in executable size.
min-crossjump-insns The minimum number of instructions which must be matched at the end of two blocks before crossjumping will be performed on them. This value is ignored in the case where all instructions in the block being crossjumped from are matched.  The default value is 5.
max-grow-copy-bb-insns The maximum code size expansion factor when copying basic blocks instead of jumping.  The expansion is relative to a jump instruction.  The default value is 8.
max-goto-duplication-insns The maximum number of instructions to duplicate to a block that jumps to a computed goto.  To avoid O(N^2) behavior in a number of passes, GCC factors computed gotos early in the compilation process, and unfactors them as late as possible.  Only computed jumps at the end of a basic blocks with no more than max-goto- duplication-insns are unfactored.  The default value is 8.
max-delay-slot-insn-search The maximum number of instructions to consider when looking for an instruction to fill a delay slot.  If more than this arbitrary number of instructions is searched, the time savings from filling the delay slot will be minimal so stop searching.  Increasing values mean more aggressive optimization, making the compile time increase with probably small improvement in executable run time.
max-delay-slot-live-search When trying to fill delay slots, the maximum number of instructions to consider when searching for a block with valid live register information.  Increasing this arbitrarily chosen value means more aggressive optimization, increasing the compile time.  This parameter should be removed when the delay slot code is rewritten to maintain the control-flow graph.
max-gcse-memory The approximate maximum amount of memory that will be allocated in order to perform the global common subexpression elimination optimization.  If more memory than specified is required, the optimization will not be done.
max-gcse-passes The maximum number of passes of GCSE to run.  The default is 1.
max-pending-list-length The maximum number of pending dependencies scheduling will allow before flushing the current state and starting over.  Large functions with few branches or calls can create excessively large lists which needlessly consume memory and resources.