Collective Knowledge Aggregator proof-of-concept
Crowdsourced experiments CK project Partners CK use cases AI powered by CK AI store Get CK
gcc-7.1.0-auto

Added by: cTuning foundation
Date: 2017-05-02 21:18:44.519818
License: See CK LICENSE.txt for licensing details
Module: compiler
Repo: ck-autotuning
CID (DOI-like distributed ID): 36ebc331048475bb:d789495b5aa52583
Tags: compiler,gcc,v7,v7.1,auto

Compiler optimization flag description (boolean and parametric)

JSON key Description Type Order Choices Parameter prefix Start Stop Step Tags
##base_opt base compiler flag text 10000 -O3, -O0, -O1, -O2, -Os, -Ofast, -Og base, basic, optimization
##bool-associative-math compiler flag: -fassociative-math text 10010 -fassociative-math, -fno-associative-math basic, boolean, optimization
##bool-auto-inc-dec compiler flag: -fauto-inc-dec text 10020 -fauto-inc-dec, -fno-auto-inc-dec basic, boolean, optimization
##bool-branch-probabilities compiler flag: -fbranch-probabilities text 10030 -fbranch-probabilities, -fno-branch-probabilities basic, boolean, optimization
##bool-branch-target-load-optimize compiler flag: -fbranch-target-load-optimize text 10040 -fbranch-target-load-optimize, -fno-branch-target-load-optimize basic, boolean, optimization
##bool-branch-target-load-optimize2 compiler flag: -fbranch-target-load-optimize2 text 10050 -fbranch-target-load-optimize2, -fno-branch-target-load-optimize2 basic, boolean, optimization
##bool-btr-bb-exclusive compiler flag: -fbtr-bb-exclusive text 10060 -fbtr-bb-exclusive, -fno-btr-bb-exclusive basic, boolean, optimization
##bool-caller-saves compiler flag: -fcaller-saves text 10070 -fcaller-saves, -fno-caller-saves basic, boolean, optimization
##bool-check-data-deps compiler flag: -fcheck-data-deps text 10080 -fcheck-data-deps, -fno-check-data-deps basic, boolean, optimization
##bool-combine-stack-adjustments compiler flag: -fcombine-stack-adjustments text 10090 -fcombine-stack-adjustments, -fno-combine-stack-adjustments basic, boolean, optimization
##bool-conserve-stack compiler flag: -fconserve-stack text 10100 -fconserve-stack, -fno-conserve-stack basic, boolean, optimization
##bool-compare-elim compiler flag: -fcompare-elim text 10110 -fcompare-elim, -fno-compare-elim basic, boolean, optimization
##bool-cprop-registers compiler flag: -fcprop-registers text 10120 -fcprop-registers, -fno-cprop-registers basic, boolean, optimization
##bool-crossjumping compiler flag: -fcrossjumping text 10130 -fcrossjumping, -fno-crossjumping basic, boolean, optimization
##bool-cse-follow-jumps compiler flag: -fcse-follow-jumps text 10140 -fcse-follow-jumps, -fno-cse-follow-jumps basic, boolean, optimization
##bool-cse-skip-blocks compiler flag: -fcse-skip-blocks text 10150 -fcse-skip-blocks, -fno-cse-skip-blocks basic, boolean, optimization
##bool-cx-fortran-rules compiler flag: -fcx-fortran-rules text 10160 -fcx-fortran-rules, -fno-cx-fortran-rules basic, boolean, optimization
##bool-cx-limited-range compiler flag: -fcx-limited-range text 10170 -fcx-limited-range, -fno-cx-limited-range basic, boolean, optimization
##bool-data-sections compiler flag: -fdata-sections text 10180 -fdata-sections, -fno-data-sections basic, boolean, optimization
##bool-dce compiler flag: -fdce text 10190 -fdce, -fno-dce basic, boolean, optimization
##bool-delayed-branch compiler flag: -fdelayed-branch text 10200 -fdelayed-branch, -fno-delayed-branch basic, boolean, optimization
##bool-delete-null-pointer-checks compiler flag: -fdelete-null-pointer-checks text 10210 -fdelete-null-pointer-checks, -fno-delete-null-pointer-checks basic, boolean, optimization
##bool-devirtualize compiler flag: -fdevirtualize text 10220 -fdevirtualize, -fno-devirtualize basic, boolean, optimization
##bool-devirtualize-speculatively compiler flag: -fdevirtualize-speculatively text 10230 -fdevirtualize-speculatively, -fno-devirtualize-speculatively basic, boolean, optimization
##bool-devirtualize-at-ltrans compiler flag: -fdevirtualize-at-ltrans text 10240 -fdevirtualize-at-ltrans, -fno-devirtualize-at-ltrans basic, boolean, optimization
##bool-dse compiler flag: -fdse text 10250 -fdse, -fno-dse basic, boolean, optimization
##bool-early-inlining compiler flag: -fearly-inlining text 10260 -fearly-inlining, -fno-early-inlining basic, boolean, optimization
##bool-ipa-sra compiler flag: -fipa-sra text 10270 -fipa-sra, -fno-ipa-sra basic, boolean, optimization
##bool-expensive-optimizations compiler flag: -fexpensive-optimizations text 10280 -fexpensive-optimizations, -fno-expensive-optimizations basic, boolean, optimization
##bool-fat-lto-objects compiler flag: -ffat-lto-objects text 10290 -ffat-lto-objects, -fno-fat-lto-objects basic, boolean, optimization
##bool-fast-math compiler flag: -ffast-math text 10300 -ffast-math, -fno-fast-math basic, boolean, optimization
##bool-finite-math-only compiler flag: -ffinite-math-only text 10310 -ffinite-math-only, -fno-finite-math-only basic, boolean, optimization
##bool-float-store compiler flag: -ffloat-store text 10320 -ffloat-store, -fno-float-store basic, boolean, optimization
##bool-forward-propagate compiler flag: -fforward-propagate text 10330 -fforward-propagate, -fno-forward-propagate basic, boolean, optimization
##bool-function-sections compiler flag: -ffunction-sections text 10340 -ffunction-sections, -fno-function-sections basic, boolean, optimization
##bool-gcse compiler flag: -fgcse text 10350 -fgcse, -fno-gcse basic, boolean, optimization
##bool-gcse-after-reload compiler flag: -fgcse-after-reload text 10360 -fgcse-after-reload, -fno-gcse-after-reload basic, boolean, optimization
##bool-gcse-las compiler flag: -fgcse-las text 10370 -fgcse-las, -fno-gcse-las basic, boolean, optimization
##bool-gcse-lm compiler flag: -fgcse-lm text 10380 -fgcse-lm, -fno-gcse-lm basic, boolean, optimization
##bool-graphite-identity compiler flag: -fgraphite-identity text 10390 -fgraphite-identity, -fno-graphite-identity basic, boolean, optimization
##bool-gcse-sm compiler flag: -fgcse-sm text 10400 -fgcse-sm, -fno-gcse-sm basic, boolean, optimization
##bool-hoist-adjacent-loads compiler flag: -fhoist-adjacent-loads text 10410 -fhoist-adjacent-loads, -fno-hoist-adjacent-loads basic, boolean, optimization
##bool-if-conversion compiler flag: -fif-conversion text 10420 -fif-conversion, -fno-if-conversion basic, boolean, optimization
##bool-if-conversion2 compiler flag: -fif-conversion2 text 10430 -fif-conversion2, -fno-if-conversion2 basic, boolean, optimization
##bool-indirect-inlining compiler flag: -findirect-inlining text 10440 -findirect-inlining, -fno-indirect-inlining basic, boolean, optimization
##bool-inline-functions compiler flag: -finline-functions text 10450 -finline-functions, -fno-inline-functions basic, boolean, optimization
##bool-inline-functions-called-once compiler flag: -finline-functions-called-once text 10460 -finline-functions-called-once, -fno-inline-functions-called-once basic, boolean, optimization
##bool-inline-small-functions compiler flag: -finline-small-functions text 10470 -finline-small-functions, -fno-inline-small-functions basic, boolean, optimization
##bool-ipa-cp compiler flag: -fipa-cp text 10480 -fipa-cp, -fno-ipa-cp basic, boolean, optimization
##bool-ipa-cp-clone compiler flag: -fipa-cp-clone text 10490 -fipa-cp-clone, -fno-ipa-cp-clone basic, boolean, optimization
##bool-ipa-cp-alignment compiler flag: -fipa-cp-alignment text 10500 -fipa-cp-alignment, -fno-ipa-cp-alignment basic, boolean, optimization
##bool-ipa-pta compiler flag: -fipa-pta text 10510 -fipa-pta, -fno-ipa-pta basic, boolean, optimization
##bool-ipa-pure-const compiler flag: -fipa-pure-const text 10520 -fipa-pure-const, -fno-ipa-pure-const basic, boolean, optimization
##bool-ipa-reference compiler flag: -fipa-reference text 10530 -fipa-reference, -fno-ipa-reference basic, boolean, optimization
##bool-ipa-icf compiler flag: -fipa-icf text 10540 -fipa-icf, -fno-ipa-icf basic, boolean, optimization
##bool-ira-hoist-pressure compiler flag: -fira-hoist-pressure text 10550 -fira-hoist-pressure, -fno-ira-hoist-pressure basic, boolean, optimization
##bool-ira-loop-pressure compiler flag: -fira-loop-pressure text 10560 -fira-loop-pressure, -fno-ira-loop-pressure basic, boolean, optimization
##bool-ira-share-save-slots compiler flag: -fno-ira-share-save-slots text 10570 -fira-share-save-slots, -fno-ira-share-save-slots basic, boolean, optimization
##bool-ira-share-spill-slots compiler flag: -fno-ira-share-spill-slots text 10580 -fira-share-spill-slots, -fno-ira-share-spill-slots basic, boolean, optimization
##bool-isolate-erroneous-paths-dereference compiler flag: -fisolate-erroneous-paths-dereference text 10590 -fisolate-erroneous-paths-dereference, -fno-isolate-erroneous-paths-dereference basic, boolean, optimization
##bool-isolate-erroneous-paths-attribute compiler flag: -fisolate-erroneous-paths-attribute text 10600 -fisolate-erroneous-paths-attribute, -fno-isolate-erroneous-paths-attribute basic, boolean, optimization
##bool-ivopts compiler flag: -fivopts text 10610 -fivopts, -fno-ivopts basic, boolean, optimization
##bool-keep-inline-functions compiler flag: -fkeep-inline-functions text 10620 -fkeep-inline-functions, -fno-keep-inline-functions basic, boolean, optimization
##bool-keep-static-consts compiler flag: -fkeep-static-consts text 10630 -fkeep-static-consts, -fno-keep-static-consts basic, boolean, optimization
##bool-live-range-shrinkage compiler flag: -flive-range-shrinkage text 10640 -flive-range-shrinkage, -fno-live-range-shrinkage basic, boolean, optimization
##bool-loop-block compiler flag: -floop-block text 10650 -floop-block, -fno-loop-block basic, boolean, optimization
##bool-loop-interchange compiler flag: -floop-interchange text 10660 -floop-interchange, -fno-loop-interchange basic, boolean, optimization
##bool-loop-strip-mine compiler flag: -floop-strip-mine text 10670 -floop-strip-mine, -fno-loop-strip-mine basic, boolean, optimization
##bool-loop-unroll-and-jam compiler flag: -floop-unroll-and-jam text 10680 -floop-unroll-and-jam, -fno-loop-unroll-and-jam basic, boolean, optimization
##bool-loop-nest-optimize compiler flag: -floop-nest-optimize text 10690 -floop-nest-optimize, -fno-loop-nest-optimize basic, boolean, optimization
##bool-loop-parallelize-all compiler flag: -floop-parallelize-all text 10700 -floop-parallelize-all, -fno-loop-parallelize-all basic, boolean, optimization
##bool-lra-remat compiler flag: -flra-remat text 10710 -flra-remat, -fno-lra-remat basic, boolean, optimization
##bool-lto compiler flag: -flto text 10720 -flto, -fno-lto basic, boolean, optimization
##bool-merge-all-constants compiler flag: -fmerge-all-constants text 10760 -fmerge-all-constants, -fno-merge-all-constants basic, boolean, optimization
##bool-merge-constants compiler flag: -fmerge-constants text 10770 -fmerge-constants, -fno-merge-constants basic, boolean, optimization
##bool-modulo-sched compiler flag: -fmodulo-sched text 10780 -fmodulo-sched, -fno-modulo-sched basic, boolean, optimization
##bool-modulo-sched-allow-regmoves compiler flag: -fmodulo-sched-allow-regmoves text 10790 -fmodulo-sched-allow-regmoves, -fno-modulo-sched-allow-regmoves basic, boolean, optimization
##bool-move-loop-invariants compiler flag: -fmove-loop-invariants text 10800 -fmove-loop-invariants, -fno-move-loop-invariants basic, boolean, optimization
##bool-branch-count-reg compiler flag: -fno-branch-count-reg text 10810 -fbranch-count-reg, -fno-branch-count-reg basic, boolean, optimization
##bool-defer-pop compiler flag: -fno-defer-pop text 10820 -fdefer-pop, -fno-defer-pop basic, boolean, optimization
##bool-function-cse compiler flag: -fno-function-cse text 10830 -ffunction-cse, -fno-function-cse basic, boolean, optimization
##bool-guess-branch-probability compiler flag: -fno-guess-branch-probability text 10840 -fguess-branch-probability, -fno-guess-branch-probability basic, boolean, optimization
##bool-inline compiler flag: -fno-inline text 10850 -finline, -fno-inline basic, boolean, optimization
##bool-math-errno compiler flag: -fno-math-errno text 10860 -fmath-errno, -fno-math-errno basic, boolean, optimization
##bool-peephole compiler flag: -fno-peephole text 10870 -fpeephole, -fno-peephole basic, boolean, optimization
##bool-peephole2 compiler flag: -fno-peephole2 text 10880 -fpeephole2, -fno-peephole2 basic, boolean, optimization
##bool-sched-interblock compiler flag: -fno-sched-interblock text 10890 -fsched-interblock, -fno-sched-interblock basic, boolean, optimization
##bool-sched-spec compiler flag: -fno-sched-spec text 10900 -fsched-spec, -fno-sched-spec basic, boolean, optimization
##bool-signed-zeros compiler flag: -fno-signed-zeros text 10910 -fsigned-zeros, -fno-signed-zeros basic, boolean, optimization
##bool-toplevel-reorder compiler flag: -fno-toplevel-reorder text 10920 -ftoplevel-reorder, -fno-toplevel-reorder basic, boolean, optimization
##bool-trapping-math compiler flag: -fno-trapping-math text 10930 -ftrapping-math, -fno-trapping-math basic, boolean, optimization
##bool-zero-initialized-in-bss compiler flag: -fno-zero-initialized-in-bss text 10940 -fzero-initialized-in-bss, -fno-zero-initialized-in-bss basic, boolean, optimization
##bool-omit-frame-pointer compiler flag: -fomit-frame-pointer text 10950 -fomit-frame-pointer, -fno-omit-frame-pointer basic, boolean, optimization
##bool-optimize-sibling-calls compiler flag: -foptimize-sibling-calls text 10960 -foptimize-sibling-calls, -fno-optimize-sibling-calls basic, boolean, optimization
##bool-partial-inlining compiler flag: -fpartial-inlining text 10970 -fpartial-inlining, -fno-partial-inlining basic, boolean, optimization
##bool-peel-loops compiler flag: -fpeel-loops text 10980 -fpeel-loops, -fno-peel-loops basic, boolean, optimization
##bool-predictive-commoning compiler flag: -fpredictive-commoning text 10990 -fpredictive-commoning, -fno-predictive-commoning basic, boolean, optimization
##bool-prefetch-loop-arrays compiler flag: -fprefetch-loop-arrays text 11000 -fprefetch-loop-arrays, -fno-prefetch-loop-arrays basic, boolean, optimization
##bool-reciprocal-math compiler flag: -freciprocal-math text 11010 -freciprocal-math, -fno-reciprocal-math basic, boolean, optimization
##bool-ree compiler flag: -free text 11020 -free, -fno-ree basic, boolean, optimization
##bool-rename-registers compiler flag: -frename-registers text 11030 -frename-registers, -fno-rename-registers basic, boolean, optimization
##bool-reorder-blocks compiler flag: -freorder-blocks text 11040 -freorder-blocks, -fno-reorder-blocks basic, boolean, optimization
##bool-reorder-blocks-and-partition compiler flag: -freorder-blocks-and-partition text 11050 -freorder-blocks-and-partition, -fno-reorder-blocks-and-partition basic, boolean, optimization
##bool-reorder-functions compiler flag: -freorder-functions text 11060 -freorder-functions, -fno-reorder-functions basic, boolean, optimization
##bool-rerun-cse-after-loop compiler flag: -frerun-cse-after-loop text 11070 -frerun-cse-after-loop, -fno-rerun-cse-after-loop basic, boolean, optimization
##bool-reschedule-modulo-scheduled-loops compiler flag: -freschedule-modulo-scheduled-loops text 11080 -freschedule-modulo-scheduled-loops, -fno-reschedule-modulo-scheduled-loops basic, boolean, optimization
##bool-rounding-math compiler flag: -frounding-math text 11090 -frounding-math, -fno-rounding-math basic, boolean, optimization
##bool-sched2-use-superblocks compiler flag: -fsched2-use-superblocks text 11100 -fsched2-use-superblocks, -fno-sched2-use-superblocks basic, boolean, optimization
##bool-sched-pressure compiler flag: -fsched-pressure text 11110 -fsched-pressure, -fno-sched-pressure basic, boolean, optimization
##bool-sched-spec-load compiler flag: -fsched-spec-load text 11120 -fsched-spec-load, -fno-sched-spec-load basic, boolean, optimization
##bool-sched-spec-load-dangerous compiler flag: -fsched-spec-load-dangerous text 11130 -fsched-spec-load-dangerous, -fno-sched-spec-load-dangerous basic, boolean, optimization
##bool-sched-group-heuristic compiler flag: -fsched-group-heuristic text 11140 -fsched-group-heuristic, -fno-sched-group-heuristic basic, boolean, optimization
##bool-sched-critical-path-heuristic compiler flag: -fsched-critical-path-heuristic text 11150 -fsched-critical-path-heuristic, -fno-sched-critical-path-heuristic basic, boolean, optimization
##bool-sched-spec-insn-heuristic compiler flag: -fsched-spec-insn-heuristic text 11160 -fsched-spec-insn-heuristic, -fno-sched-spec-insn-heuristic basic, boolean, optimization
##bool-sched-rank-heuristic compiler flag: -fsched-rank-heuristic text 11170 -fsched-rank-heuristic, -fno-sched-rank-heuristic basic, boolean, optimization
##bool-sched-last-insn-heuristic compiler flag: -fsched-last-insn-heuristic text 11180 -fsched-last-insn-heuristic, -fno-sched-last-insn-heuristic basic, boolean, optimization
##bool-sched-dep-count-heuristic compiler flag: -fsched-dep-count-heuristic text 11190 -fsched-dep-count-heuristic, -fno-sched-dep-count-heuristic basic, boolean, optimization
##bool-schedule-fusion compiler flag: -fschedule-fusion text 11200 -fschedule-fusion, -fno-schedule-fusion basic, boolean, optimization
##bool-schedule-insns compiler flag: -fschedule-insns text 11210 -fschedule-insns, -fno-schedule-insns basic, boolean, optimization
##bool-schedule-insns2 compiler flag: -fschedule-insns2 text 11220 -fschedule-insns2, -fno-schedule-insns2 basic, boolean, optimization
##bool-section-anchors compiler flag: -fsection-anchors text 11230 -fsection-anchors, -fno-section-anchors basic, boolean, optimization
##bool-selective-scheduling compiler flag: -fselective-scheduling text 11240 -fselective-scheduling, -fno-selective-scheduling basic, boolean, optimization
##bool-selective-scheduling2 compiler flag: -fselective-scheduling2 text 11250 -fselective-scheduling2, -fno-selective-scheduling2 basic, boolean, optimization
##bool-sel-sched-pipelining compiler flag: -fsel-sched-pipelining text 11260 -fsel-sched-pipelining, -fno-sel-sched-pipelining basic, boolean, optimization
##bool-sel-sched-pipelining-outer-loops compiler flag: -fsel-sched-pipelining-outer-loops text 11270 -fsel-sched-pipelining-outer-loops, -fno-sel-sched-pipelining-outer-loops basic, boolean, optimization
##bool-semantic-interposition compiler flag: -fsemantic-interposition text 11280 -fsemantic-interposition, -fno-semantic-interposition basic, boolean, optimization
##bool-shrink-wrap compiler flag: -fshrink-wrap text 11290 -fshrink-wrap, -fno-shrink-wrap basic, boolean, optimization
##bool-signaling-nans compiler flag: -fsignaling-nans text 11300 -fsignaling-nans, -fno-signaling-nans basic, boolean, optimization
##bool-single-precision-constant compiler flag: -fsingle-precision-constant text 11310 -fsingle-precision-constant, -fno-single-precision-constant basic, boolean, optimization
##bool-split-ivs-in-unroller compiler flag: -fsplit-ivs-in-unroller text 11320 -fsplit-ivs-in-unroller, -fno-split-ivs-in-unroller basic, boolean, optimization
##bool-split-wide-types compiler flag: -fsplit-wide-types text 11330 -fsplit-wide-types, -fno-split-wide-types basic, boolean, optimization
##bool-ssa-phiopt compiler flag: -fssa-phiopt text 11340 -fssa-phiopt, -fno-ssa-phiopt basic, boolean, optimization
##bool-stdarg-opt compiler flag: -fstdarg-opt text 11390 -fstdarg-opt, -fno-stdarg-opt basic, boolean, optimization
##bool-strict-aliasing compiler flag: -fstrict-aliasing text 11400 -fstrict-aliasing, -fno-strict-aliasing basic, boolean, optimization
##bool-strict-overflow compiler flag: -fstrict-overflow text 11410 -fstrict-overflow, -fno-strict-overflow basic, boolean, optimization
##bool-thread-jumps compiler flag: -fthread-jumps text 11420 -fthread-jumps, -fno-thread-jumps basic, boolean, optimization
##bool-tracer compiler flag: -ftracer text 11430 -ftracer, -fno-tracer basic, boolean, optimization
##bool-tree-bit-ccp compiler flag: -ftree-bit-ccp text 11440 -ftree-bit-ccp, -fno-tree-bit-ccp basic, boolean, optimization
##bool-tree-builtin-call-dce compiler flag: -ftree-builtin-call-dce text 11450 -ftree-builtin-call-dce, -fno-tree-builtin-call-dce basic, boolean, optimization
##bool-tree-ccp compiler flag: -ftree-ccp text 11460 -ftree-ccp, -fno-tree-ccp basic, boolean, optimization
##bool-tree-ch compiler flag: -ftree-ch text 11470 -ftree-ch, -fno-tree-ch basic, boolean, optimization
##bool-tree-coalesce-vars compiler flag: -ftree-coalesce-vars text 11490 -ftree-coalesce-vars, -fno-tree-coalesce-vars basic, boolean, optimization
##bool-tree-copy-prop compiler flag: -ftree-copy-prop text 11500 -ftree-copy-prop, -fno-tree-copy-prop basic, boolean, optimization
##bool-tree-copyrename compiler flag: -ftree-copyrename text 11510 -ftree-copyrename, -fno-tree-copyrename basic, boolean, optimization
##bool-tree-dce compiler flag: -ftree-dce text 11520 -ftree-dce, -fno-tree-dce basic, boolean, optimization
##bool-tree-dominator-opts compiler flag: -ftree-dominator-opts text 11530 -ftree-dominator-opts, -fno-tree-dominator-opts basic, boolean, optimization
##bool-tree-dse compiler flag: -ftree-dse text 11540 -ftree-dse, -fno-tree-dse basic, boolean, optimization
##bool-tree-forwprop compiler flag: -ftree-forwprop text 11550 -ftree-forwprop, -fno-tree-forwprop basic, boolean, optimization
##bool-tree-fre compiler flag: -ftree-fre text 11560 -ftree-fre, -fno-tree-fre basic, boolean, optimization
##bool-tree-loop-if-convert compiler flag: -ftree-loop-if-convert text 11570 -ftree-loop-if-convert, -fno-tree-loop-if-convert basic, boolean, optimization
##bool-tree-loop-if-convert-stores compiler flag: -ftree-loop-if-convert-stores text 11580 -ftree-loop-if-convert-stores, -fno-tree-loop-if-convert-stores basic, boolean, optimization
##bool-tree-loop-im compiler flag: -ftree-loop-im text 11590 -ftree-loop-im, -fno-tree-loop-im basic, boolean, optimization
##bool-tree-phiprop compiler flag: -ftree-phiprop text 11600 -ftree-phiprop, -fno-tree-phiprop basic, boolean, optimization
##bool-tree-loop-distribution compiler flag: -ftree-loop-distribution text 11610 -ftree-loop-distribution, -fno-tree-loop-distribution basic, boolean, optimization
##bool-tree-loop-distribute-patterns compiler flag: -ftree-loop-distribute-patterns text 11620 -ftree-loop-distribute-patterns, -fno-tree-loop-distribute-patterns basic, boolean, optimization
##bool-tree-loop-ivcanon compiler flag: -ftree-loop-ivcanon text 11630 -ftree-loop-ivcanon, -fno-tree-loop-ivcanon basic, boolean, optimization
##bool-tree-loop-linear compiler flag: -ftree-loop-linear text 11640 -ftree-loop-linear, -fno-tree-loop-linear basic, boolean, optimization
##bool-tree-loop-optimize compiler flag: -ftree-loop-optimize text 11650 -ftree-loop-optimize, -fno-tree-loop-optimize basic, boolean, optimization
##bool-tree-loop-vectorize compiler flag: -ftree-loop-vectorize text 11660 -ftree-loop-vectorize, -fno-tree-loop-vectorize basic, boolean, optimization
##bool-tree-pre compiler flag: -ftree-pre text 11670 -ftree-pre, -fno-tree-pre basic, boolean, optimization
##bool-tree-partial-pre compiler flag: -ftree-partial-pre text 11680 -ftree-partial-pre, -fno-tree-partial-pre basic, boolean, optimization
##bool-tree-pta compiler flag: -ftree-pta text 11690 -ftree-pta, -fno-tree-pta basic, boolean, optimization
##bool-tree-reassoc compiler flag: -ftree-reassoc text 11700 -ftree-reassoc, -fno-tree-reassoc basic, boolean, optimization
##bool-tree-sink compiler flag: -ftree-sink text 11710 -ftree-sink, -fno-tree-sink basic, boolean, optimization
##bool-tree-slsr compiler flag: -ftree-slsr text 11720 -ftree-slsr, -fno-tree-slsr basic, boolean, optimization
##bool-tree-sra compiler flag: -ftree-sra text 11730 -ftree-sra, -fno-tree-sra basic, boolean, optimization
##bool-tree-switch-conversion compiler flag: -ftree-switch-conversion text 11740 -ftree-switch-conversion, -fno-tree-switch-conversion basic, boolean, optimization
##bool-tree-tail-merge compiler flag: -ftree-tail-merge text 11750 -ftree-tail-merge, -fno-tree-tail-merge basic, boolean, optimization
##bool-tree-ter compiler flag: -ftree-ter text 11760 -ftree-ter, -fno-tree-ter basic, boolean, optimization
##bool-tree-vectorize compiler flag: -ftree-vectorize text 11770 -ftree-vectorize, -fno-tree-vectorize basic, boolean, optimization
##bool-tree-vrp compiler flag: -ftree-vrp text 11780 -ftree-vrp, -fno-tree-vrp basic, boolean, optimization
##bool-unit-at-a-time compiler flag: -funit-at-a-time text 11790 -funit-at-a-time, -fno-unit-at-a-time basic, boolean, optimization
##bool-unroll-all-loops compiler flag: -funroll-all-loops text 11800 -funroll-all-loops, -fno-unroll-all-loops basic, boolean, optimization
##bool-unroll-loops compiler flag: -funroll-loops text 11810 -funroll-loops, -fno-unroll-loops basic, boolean, optimization
##bool-unsafe-loop-optimizations compiler flag: -funsafe-loop-optimizations text 11820 -funsafe-loop-optimizations, -fno-unsafe-loop-optimizations basic, boolean, optimization
##bool-unsafe-math-optimizations compiler flag: -funsafe-math-optimizations text 11830 -funsafe-math-optimizations, -fno-unsafe-math-optimizations basic, boolean, optimization
##bool-unswitch-loops compiler flag: -funswitch-loops text 11840 -funswitch-loops, -fno-unswitch-loops basic, boolean, optimization
##bool-ipa-ra compiler flag: -fipa-ra text 11850 -fipa-ra, -fno-ipa-ra basic, boolean, optimization
##bool-variable-expansion-in-unroller compiler flag: -fvariable-expansion-in-unroller text 11860 -fvariable-expansion-in-unroller, -fno-variable-expansion-in-unroller basic, boolean, optimization
##bool-vect-cost-model compiler flag: -fvect-cost-model text 11870 -fvect-cost-model, -fno-vect-cost-model basic, boolean, optimization
##bool-vpt compiler flag: -fvpt text 11880 -fvpt, -fno-vpt basic, boolean, optimization
##bool-web compiler flag: -fweb text 11890 -fweb, -fno-web basic, boolean, optimization
##bool-whole-program compiler flag: -fwhole-program text 11900 -fwhole-program, -fno-whole-program basic, boolean, optimization
##bool-wpa compiler flag: -fwpa text 11910 -fwpa, -fno-wpa basic, boolean, optimization
##bool-use-linker-plugin compiler flag: -fuse-linker-plugin text 11920 -fuse-linker-plugin, -fno-use-linker-plugin basic, boolean, optimization
##param--falign-functions compiler flag: -falign-functions= integer 30010 -falign-functions= 0 0 1 basic, parametric, optimization
##param--falign-jumps compiler flag: -falign-jumps= integer 30020 -falign-jumps= 0 0 1 basic, parametric, optimization
##param--falign-labels compiler flag: -falign-labels= integer 30030 -falign-labels= 0 0 1 basic, parametric, optimization
##param--falign-loops compiler flag: -falign-loops= integer 30040 -falign-loops= 0 0 1 basic, parametric, optimization
##bool--fexcess-precision= compiler flag: -fexcess-precision= text 30050 -fexcess-precision=fast, -fexcess-precision=standard basic, boolean, optimization
##bool--ffp-contract= compiler flag: -ffp-contract= text 30060 -ffp-contract=fast, -ffp-contract=on, -ffp-contract=off basic, boolean, optimization
##param--finline-limit= compiler flag: -finline-limit= integer 30070 -finline-limit= 0 0 1 basic, parametric, optimization
##bool--fira-algorithm= compiler flag: -fira-algorithm= text 30080 -fira-algorithm=CB, -fira-algorithm=priority basic, boolean, optimization
##bool--fira-region= compiler flag: -fira-region= text 30090 -fira-region=all, -fira-region=mixed, -fira-region=one basic, boolean, optimization
##bool--flto-partition= compiler flag: -flto-partition= text 30110 -flto-partition=1to1, -flto-partition=balanced, -flto-partition=max, -flto-partition=one, -flto-partition=none basic, boolean, optimization
##param--fsched-stalled-insns-dep compiler flag: -fsched-stalled-insns-dep= integer 30120 -fsched-stalled-insns-dep= 0 0 1 basic, parametric, optimization
##param--fsched-stalled-insns compiler flag: -fsched-stalled-insns= integer 30130 -fsched-stalled-insns= 0 0 1 basic, parametric, optimization
##param--ftree-parallelize-loops= compiler flag: -ftree-parallelize-loops= integer 30140 -ftree-parallelize-loops= 0 0 1 basic, parametric, optimization
##param-predictable-branch-outcome compiler flag: --param predictable-branch-outcome= (Maximal estimated outcome of branch considered predictable) integer 30150 --param predictable-branch-outcome= 0 50 1 basic, parametric, optimization
##param-inline-min-speedup compiler flag: --param inline-min-speedup= (The minimal estimated speedup allowing inliner to ignore inline-insns-single and inline-isnsns-auto) integer 30160 --param inline-min-speedup= 0 20 1 basic, parametric, optimization
##param-max-inline-insns-single compiler flag: --param max-inline-insns-single= (The maximum number of instructions in a single function eligible for inlining) integer 30170 --param max-inline-insns-single= 0 800 1 basic, parametric, optimization
##param-max-inline-insns-auto compiler flag: --param max-inline-insns-auto= (The maximum number of instructions when automatically inlining) integer 30180 --param max-inline-insns-auto= 0 80 1 basic, parametric, optimization
##param-max-inline-insns-recursive compiler flag: --param max-inline-insns-recursive= (The maximum number of instructions inline function can grow to via recursive inlining) integer 30190 --param max-inline-insns-recursive= 0 900 1 basic, parametric, optimization
##param-max-inline-insns-recursive-auto compiler flag: --param max-inline-insns-recursive-auto= (The maximum number of instructions non-inline function can grow to via recursive inlining) integer 30200 --param max-inline-insns-recursive-auto= 0 900 1 basic, parametric, optimization
##param-max-inline-recursive-depth compiler flag: --param max-inline-recursive-depth= (The maximum depth of recursive inlining for inline functions) integer 30210 --param max-inline-recursive-depth= 0 16 1 basic, parametric, optimization
##param-max-inline-recursive-depth-auto compiler flag: --param max-inline-recursive-depth-auto= (The maximum depth of recursive inlining for non-inline functions) integer 30220 --param max-inline-recursive-depth-auto= 0 16 1 basic, parametric, optimization
##param-min-inline-recursive-probability compiler flag: --param min-inline-recursive-probability= (Inline recursively only when the probability of call being executed exceeds the parameter) integer 30230 --param min-inline-recursive-probability= 0 20 1 basic, parametric, optimization
##param-max-early-inliner-iterations compiler flag: --param max-early-inliner-iterations= (The maximum number of nested indirect inlining performed by early inliner) integer 30240 --param max-early-inliner-iterations= 0 2 1 basic, parametric, optimization
##param-comdat-sharing-probability compiler flag: --param comdat-sharing-probability= (Probability that COMDAT function will be shared with different compilation unit) integer 30250 --param comdat-sharing-probability= 0 40 1 basic, parametric, optimization
##param-partial-inlining-entry-probability compiler flag: --param partial-inlining-entry-probability= (Maximum probability of the entry BB of split region (in percent relative to entry BB of the function) to make partial inlining happen) integer 30260 --param partial-inlining-entry-probability= 0 140 1 basic, parametric, optimization
##param-max-variable-expansions-in-unroller compiler flag: --param max-variable-expansions-in-unroller= (If -fvariable-expansion-in-unroller is used, the maximum number of times that an individual variable will be expanded during loop unrolling) integer 30270 --param max-variable-expansions-in-unroller= 0 2 1 basic, parametric, optimization
##param-min-vect-loop-bound compiler flag: --param min-vect-loop-bound= (If -ftree-vectorize is used, the minimal loop bound of a loop to be considered for vectorization) integer 30280 --param min-vect-loop-bound= 1 2 1 basic, parametric, optimization
##param-max-delay-slot-insn-search compiler flag: --param max-delay-slot-insn-search= (The maximum number of instructions to consider to fill a delay slot) integer 30290 --param max-delay-slot-insn-search= 0 200 1 basic, parametric, optimization
##param-max-delay-slot-live-search compiler flag: --param max-delay-slot-live-search= (The maximum number of instructions to consider to find accurate live register information) integer 30300 --param max-delay-slot-live-search= 0 666 1 basic, parametric, optimization
##param-max-pending-list-length compiler flag: --param max-pending-list-length= (The maximum length of scheduling's pending operations list) integer 30310 --param max-pending-list-length= 0 64 1 basic, parametric, optimization
##param-max-modulo-backtrack-attempts compiler flag: --param max-modulo-backtrack-attempts= (The maximum number of backtrack attempts the scheduler should make when modulo scheduling a loop) integer 30320 --param max-modulo-backtrack-attempts= 0 80 1 basic, parametric, optimization
##param-large-function-insns compiler flag: --param large-function-insns= (The size of function body to be considered large) integer 30330 --param large-function-insns= 0 5400 1 basic, parametric, optimization
##param-large-function-growth compiler flag: --param large-function-growth= (Maximal growth due to inlining of large function (in percent)) integer 30340 --param large-function-growth= 0 200 1 basic, parametric, optimization
##param-large-unit-insns compiler flag: --param large-unit-insns= (The size of translation unit to be considered large) integer 30350 --param large-unit-insns= 0 20000 1 basic, parametric, optimization
##param-inline-unit-growth compiler flag: --param inline-unit-growth= (How much can given compilation unit grow because of the inlining (in percent)) integer 30360 --param inline-unit-growth= 0 40 1 basic, parametric, optimization
##param-ipcp-unit-growth compiler flag: --param ipcp-unit-growth= (How much can given compilation unit grow because of the interprocedural constant propagation (in percent)) integer 30370 --param ipcp-unit-growth= 0 20 1 basic, parametric, optimization
##param-early-inlining-insns compiler flag: --param early-inlining-insns= (Maximal estimated growth of function body caused by early inlining of single call) integer 30380 --param early-inlining-insns= 0 28 1 basic, parametric, optimization
##param-large-stack-frame compiler flag: --param large-stack-frame= (The size of stack frame to be considered large) integer 30390 --param large-stack-frame= 0 512 1 basic, parametric, optimization
##param-large-stack-frame-growth compiler flag: --param large-stack-frame-growth= (Maximal stack frame growth due to inlining (in percent)) integer 30400 --param large-stack-frame-growth= 0 2000 1 basic, parametric, optimization
##param-max-gcse-insertion-ratio compiler flag: --param max-gcse-insertion-ratio= (The maximum ratio of insertions to deletions of expressions in GCSE) integer 30420 --param max-gcse-insertion-ratio= 0 40 1 basic, parametric, optimization
##param-gcse-after-reload-partial-fraction compiler flag: --param gcse-after-reload-partial-fraction= (The threshold ratio for performing partial redundancy elimination after reload) integer 30430 --param gcse-after-reload-partial-fraction= 0 6 1 basic, parametric, optimization
##param-gcse-after-reload-critical-fraction compiler flag: --param gcse-after-reload-critical-fraction= (The threshold ratio of critical edges execution count that permit performing redundancy elimination after reload) integer 30440 --param gcse-after-reload-critical-fraction= 0 20 1 basic, parametric, optimization
##param-gcse-cost-distance-ratio compiler flag: --param gcse-cost-distance-ratio= (Scaling factor in calculation of maximum distance an expression can be moved by GCSE optimizations) integer 30450 --param gcse-cost-distance-ratio= 0 20 1 basic, parametric, optimization
##param-gcse-unrestricted-cost compiler flag: --param gcse-unrestricted-cost= (Cost at which GCSE optimizations will not constraint the distance an expression can travel) integer 30460 --param gcse-unrestricted-cost= 0 6 1 basic, parametric, optimization
##param-max-hoist-depth compiler flag: --param max-hoist-depth= (Maximum depth of search in the dominator tree for expressions to hoist) integer 30470 --param max-hoist-depth= 0 60 1 basic, parametric, optimization
##param-max-unrolled-insns compiler flag: --param max-unrolled-insns= (The maximum number of instructions to consider to unroll in a loop) integer 30480 --param max-unrolled-insns= 0 400 1 basic, parametric, optimization
##param-max-average-unrolled-insns compiler flag: --param max-average-unrolled-insns= (The maximum number of instructions to consider to unroll in a loop on average) integer 30490 --param max-average-unrolled-insns= 0 160 1 basic, parametric, optimization
##param-max-unroll-times compiler flag: --param max-unroll-times= (The maximum number of unrollings of a single loop) integer 30500 --param max-unroll-times= 0 16 1 basic, parametric, optimization
##param-max-peeled-insns compiler flag: --param max-peeled-insns= (The maximum number of insns of a peeled loop) integer 30510 --param max-peeled-insns= 0 200 1 basic, parametric, optimization
##param-max-peel-times compiler flag: --param max-peel-times= (The maximum number of peelings of a single loop) integer 30520 --param max-peel-times= 0 32 1 basic, parametric, optimization
##param-max-peel-branches compiler flag: --param max-peel-branches= (The maximum number of branches on the path through the peeled sequence) integer 30530 --param max-peel-branches= 0 64 1 basic, parametric, optimization
##param-max-completely-peeled-insns compiler flag: --param max-completely-peeled-insns= (The maximum number of insns of a completely peeled loop) integer 30540 --param max-completely-peeled-insns= 0 400 1 basic, parametric, optimization
##param-max-completely-peel-times compiler flag: --param max-completely-peel-times= (The maximum number of peelings of a single loop that is peeled completely) integer 30550 --param max-completely-peel-times= 0 32 1 basic, parametric, optimization
##param-max-once-peeled-insns compiler flag: --param max-once-peeled-insns= (The maximum number of insns of a peeled loop that rolls only once) integer 30560 --param max-once-peeled-insns= 0 800 1 basic, parametric, optimization
##param-max-completely-peel-loop-nest-depth compiler flag: --param max-completely-peel-loop-nest-depth= (The maximum depth of a loop nest we completely peel) integer 30570 --param max-completely-peel-loop-nest-depth= 0 16 1 basic, parametric, optimization
##param-max-unswitch-insns compiler flag: --param max-unswitch-insns= (The maximum number of insns of an unswitched loop) integer 30580 --param max-unswitch-insns= 0 100 1 basic, parametric, optimization
##param-max-unswitch-level compiler flag: --param max-unswitch-level= (The maximum number of unswitchings in a single loop) integer 30590 --param max-unswitch-level= 0 6 1 basic, parametric, optimization
##param-max-iterations-to-track compiler flag: --param max-iterations-to-track= (Bound on the number of iterations the brute force # of iterations analysis algorithm evaluates) integer 30600 --param max-iterations-to-track= 0 2000 1 basic, parametric, optimization
##param-max-iterations-computation-cost compiler flag: --param max-iterations-computation-cost= (Bound on the cost of an expression to compute the number of iterations) integer 30610 --param max-iterations-computation-cost= 0 20 1 basic, parametric, optimization
##param-sms-max-ii-factor compiler flag: --param sms-max-ii-factor= (A factor for tuning the upper bound that swing modulo scheduler uses for scheduling a loop) integer 30620 --param sms-max-ii-factor= 0 200 1 basic, parametric, optimization
##param-sms-min-sc compiler flag: --param sms-min-sc= (The minimum value of stage count that swing modulo scheduler will generate.) integer 30630 --param sms-min-sc= 1 4 1 basic, parametric, optimization
##param-sms-dfa-history compiler flag: --param sms-dfa-history= (The number of cycles the swing modulo scheduler considers when checking conflicts using DFA) integer 30640 --param sms-dfa-history= 0 0 1 basic, parametric, optimization
##param-sms-loop-average-count-threshold compiler flag: --param sms-loop-average-count-threshold= (A threshold on the average loop count considered by the swing modulo scheduler) integer 30650 --param sms-loop-average-count-threshold= 0 0 1 basic, parametric, optimization
##param-hot-bb-count-ws-permille compiler flag: --param hot-bb-count-ws-permille= (A basic block profile count is considered hot if it contributes tothe given permillage of the entire profiled execution) integer 30660 --param hot-bb-count-ws-permille= 0 1000 1 basic, parametric, optimization
##param-hot-bb-frequency-fraction compiler flag: --param hot-bb-frequency-fraction= (Select fraction of the maximal frequency of executions of basic block in function given basic block needs to have to be considered hot) integer 30670 --param hot-bb-frequency-fraction= 0 2000 1 basic, parametric, optimization
##param-unlikely-bb-count-fraction compiler flag: --param unlikely-bb-count-fraction= (The minimum fraction of profile runs a given basic block execution count must be not to be considered unlikely) integer 30680 --param unlikely-bb-count-fraction= 1 10000 1 basic, parametric, optimization
##param-align-threshold compiler flag: --param align-threshold= (Select fraction of the maximal frequency of executions of basic block in function given basic block get alignment) integer 30690 --param align-threshold= 1 200 1 basic, parametric, optimization
##param-align-loop-iterations compiler flag: --param align-loop-iterations= (Loops iterating at least selected number of iterations will get loop alignement.) integer 30700 --param align-loop-iterations= 0 8 1 basic, parametric, optimization
##param-max-predicted-iterations compiler flag: --param max-predicted-iterations= (The maximum number of loop iterations we predict statically) integer 30710 --param max-predicted-iterations= 0 200 1 basic, parametric, optimization
##param-builtin-expect-probability compiler flag: --param builtin-expect-probability= (Set the estimated probability in percentage for builtin expect. The default value is 90% probability.) integer 30720 --param builtin-expect-probability= 0 100 1 basic, parametric, optimization
##param-tracer-max-code-growth compiler flag: --param tracer-max-code-growth= (Maximal code growth caused by tail duplication (in percent)) integer 30750 --param tracer-max-code-growth= 0 200 1 basic, parametric, optimization
##param-tracer-min-branch-ratio compiler flag: --param tracer-min-branch-ratio= (Stop reverse growth if the reverse probability of best edge is less than this threshold (in percent)) integer 30760 --param tracer-min-branch-ratio= 0 100 1 basic, parametric, optimization
##param-tracer-min-branch-probability-feedback compiler flag: --param tracer-min-branch-probability-feedback= (Stop forward growth if the probability of best edge is less than this threshold (in percent). Used when profile feedback is available) integer 30770 --param tracer-min-branch-probability-feedback= 0 100 1 basic, parametric, optimization
##param-tracer-min-branch-probability compiler flag: --param tracer-min-branch-probability= (Stop forward growth if the probability of best edge is less than this threshold (in percent). Used when profile feedback is not available) integer 30780 --param tracer-min-branch-probability= 0 100 1 basic, parametric, optimization
##param-max-crossjump-edges compiler flag: --param max-crossjump-edges= (The maximum number of incoming edges to consider for crossjumping) integer 30790 --param max-crossjump-edges= 0 200 1 basic, parametric, optimization
##param-min-crossjump-insns compiler flag: --param min-crossjump-insns= (The minimum number of matching instructions to consider for crossjumping) integer 30800 --param min-crossjump-insns= 1 10 1 basic, parametric, optimization
##param-max-grow-copy-bb-insns compiler flag: --param max-grow-copy-bb-insns= (The maximum expansion factor when copying basic blocks) integer 30810 --param max-grow-copy-bb-insns= 0 16 1 basic, parametric, optimization
##param-max-goto-duplication-insns compiler flag: --param max-goto-duplication-insns= (The maximum number of insns to duplicate when unfactoring computed gotos) integer 30820 --param max-goto-duplication-insns= 0 16 1 basic, parametric, optimization
##param-max-cse-path-length compiler flag: --param max-cse-path-length= (The maximum length of path considered in cse) integer 30830 --param max-cse-path-length= 1 20 1 basic, parametric, optimization
##param-max-cse-insns compiler flag: --param max-cse-insns= (The maximum instructions CSE process before flushing) integer 30840 --param max-cse-insns= 0 2000 1 basic, parametric, optimization
##param-lim-expensive compiler flag: --param lim-expensive= (The minimum cost of an expensive expression in the loop invariant motion) integer 30850 --param lim-expensive= 0 40 1 basic, parametric, optimization
##param-iv-consider-all-candidates-bound compiler flag: --param iv-consider-all-candidates-bound= (Bound on number of candidates below that all candidates are considered in iv optimizations) integer 30860 --param iv-consider-all-candidates-bound= 0 60 1 basic, parametric, optimization
##param-iv-max-considered-uses compiler flag: --param iv-max-considered-uses= (Bound on number of iv uses in loop optimized in iv optimizations) integer 30870 --param iv-max-considered-uses= 0 500 1 basic, parametric, optimization
##param-iv-always-prune-cand-set-bound compiler flag: --param iv-always-prune-cand-set-bound= (If number of candidates in the set is smaller, we always try to remove unused ivs during its optimization) integer 30880 --param iv-always-prune-cand-set-bound= 0 20 1 basic, parametric, optimization
##param-scev-max-expr-size compiler flag: --param scev-max-expr-size= (Bound on size of expressions used in the scalar evolutions analyzer) integer 30890 --param scev-max-expr-size= 0 200 1 basic, parametric, optimization
##param-scev-max-expr-complexity compiler flag: --param scev-max-expr-complexity= (Bound on the complexity of the expressions in the scalar evolutions analyzer) integer 30900 --param scev-max-expr-complexity= 0 20 1 basic, parametric, optimization
##param-vect-max-version-for-alignment-checks compiler flag: --param vect-max-version-for-alignment-checks= (Bound on number of runtime checks inserted by the vectorizer's loop versioning for alignment check) integer 30980 --param vect-max-version-for-alignment-checks= 0 12 1 basic, parametric, optimization
##param-vect-max-version-for-alias-checks compiler flag: --param vect-max-version-for-alias-checks= (Bound on number of runtime checks inserted by the vectorizer's loop versioning for alias check) integer 30990 --param vect-max-version-for-alias-checks= 0 20 1 basic, parametric, optimization
##arch-arm-mfpu-neon compiler flag (ARM specific): -mfpu=neon text 30990 -mfpu=neon, basic, optimization, arm-neon
##arch-mtune-native compiler flag (CPU specific): -mtune=native text 30991 -mtune=native, basic, optimization, cpu-specific
##param-vect-max-peeling-for-alignment compiler flag: --param vect-max-peeling-for-alignment= (Max number of loop peels to enhancement alignment of data references in a loop) integer 31000 --param vect-max-peeling-for-alignment= 1 64 1 basic, parametric, optimization
##param-max-cselib-memory-locations compiler flag: --param max-cselib-memory-locations= (The maximum memory locations recorded by cselib) integer 31010 --param max-cselib-memory-locations= 0 1000 1 basic, parametric, optimization
##param-max-reload-search-insns compiler flag: --param max-reload-search-insns= (The maximum number of instructions to search backward when looking for equivalent reload) integer 31040 --param max-reload-search-insns= 0 200 1 basic, parametric, optimization
##param-sink-frequency-threshold compiler flag: --param sink-frequency-threshold= (Target block's relative execution frequency (as a percentage) required to sink a statement) integer 31050 --param sink-frequency-threshold= 0 100 1 basic, parametric, optimization
##param-max-sched-region-blocks compiler flag: --param max-sched-region-blocks= (The maximum number of blocks in a region to be considered for interblock scheduling) integer 31060 --param max-sched-region-blocks= 0 20 1 basic, parametric, optimization
##param-max-sched-region-insns compiler flag: --param max-sched-region-insns= (The maximum number of insns in a region to be considered for interblock scheduling) integer 31070 --param max-sched-region-insns= 0 200 1 basic, parametric, optimization
##param-max-pipeline-region-blocks compiler flag: --param max-pipeline-region-blocks= (The maximum number of blocks in a region to be considered for interblock scheduling) integer 31080 --param max-pipeline-region-blocks= 0 30 1 basic, parametric, optimization
##param-max-pipeline-region-insns compiler flag: --param max-pipeline-region-insns= (The maximum number of insns in a region to be considered for interblock scheduling) integer 31090 --param max-pipeline-region-insns= 0 400 1 basic, parametric, optimization
##param-min-spec-prob compiler flag: --param min-spec-prob= (The minimum probability of reaching a source block for interblock speculative scheduling) integer 31100 --param min-spec-prob= 0 80 1 basic, parametric, optimization
##param-max-sched-extend-regions-iters compiler flag: --param max-sched-extend-regions-iters= (The maximum number of iterations through CFG to extend regions) integer 31110 --param max-sched-extend-regions-iters= 0 0 1 basic, parametric, optimization
##param-max-sched-insn-conflict-delay compiler flag: --param max-sched-insn-conflict-delay= (The maximum conflict delay for an insn to be considered for speculative motion) integer 31120 --param max-sched-insn-conflict-delay= 1 10 1 basic, parametric, optimization
##param-sched-spec-prob-cutoff compiler flag: --param sched-spec-prob-cutoff= (The minimal probability of speculation success (in percents), so that speculative insn will be scheduled.) integer 31130 --param sched-spec-prob-cutoff= 0 100 1 basic, parametric, optimization
##param-sched-state-edge-prob-cutoff compiler flag: --param sched-state-edge-prob-cutoff= (The minimum probability an edge must have for the scheduler to save its state across it.) integer 31140 --param sched-state-edge-prob-cutoff= 0 100 1 basic, parametric, optimization
##param-selsched-max-lookahead compiler flag: --param selsched-max-lookahead= (The maximum size of the lookahead window of selective scheduling) integer 31150 --param selsched-max-lookahead= 0 100 1 basic, parametric, optimization
##param-selsched-max-sched-times compiler flag: --param selsched-max-sched-times= (Maximum number of times that an insn could be scheduled) integer 31160 --param selsched-max-sched-times= 0 4 1 basic, parametric, optimization
##param-selsched-insns-to-rename compiler flag: --param selsched-insns-to-rename= (Maximum number of instructions in the ready list that are considered eligible for renaming) integer 31170 --param selsched-insns-to-rename= 0 4 1 basic, parametric, optimization
##param-sched-mem-true-dep-cost compiler flag: --param sched-mem-true-dep-cost= (Minimal distance between possibly conflicting store and load) integer 31180 --param sched-mem-true-dep-cost= 0 2 1 basic, parametric, optimization
##param-sched-autopref-queue-depth compiler flag: --param sched-autopref-queue-depth= (Hardware autoprefetcher scheduler model control flag. Number of lookahead cycles the model looks into; at '0' only enable instruction sorting heuristic. Disabled by default.) integer 31190 --param sched-autopref-queue-depth= 0 -2 1 basic, parametric, optimization
##param-max-last-value-rtl compiler flag: --param max-last-value-rtl= (The maximum number of RTL nodes that can be recorded as combiner's last value) integer 31200 --param max-last-value-rtl= 0 20000 1 basic, parametric, optimization
##param-max-combine-insns compiler flag: --param max-combine-insns= (The maximum number of insns combine tries to combine) integer 31210 --param max-combine-insns= 2 4 1 basic, parametric, optimization
##param-integer-share-limit compiler flag: --param integer-share-limit= (The upper bound for sharing integer constants) integer 31220 --param integer-share-limit= 2 502 1 basic, parametric, optimization
##param-ssp-buffer-size compiler flag: --param ssp-buffer-size= (The lower bound for a buffer to be considered for stack smashing protection) integer 31230 --param ssp-buffer-size= 1 16 1 basic, parametric, optimization
##param-min-size-for-stack-sharing compiler flag: --param min-size-for-stack-sharing= (The minimum size of variables taking part in stack slot sharingwhen not optimizing) integer 31240 --param min-size-for-stack-sharing= 0 64 1 basic, parametric, optimization
##param-max-jump-thread-duplication-stmts compiler flag: --param max-jump-thread-duplication-stmts= (Maximum number of statements allowed in a block that needs to be duplicated when threading jumps) integer 31250 --param max-jump-thread-duplication-stmts= 0 30 1 basic, parametric, optimization
##param-max-fields-for-field-sensitive compiler flag: --param max-fields-for-field-sensitive= (Maximum number of fields in a structure before pointer analysis treats the structure as a single variable) integer 31260 --param max-fields-for-field-sensitive= 0 0 1 basic, parametric, optimization
##param-max-sched-ready-insns compiler flag: --param max-sched-ready-insns= (The maximum number of instructions ready to be issued to be considered by the scheduler during the first scheduling pass) integer 31270 --param max-sched-ready-insns= 0 200 1 basic, parametric, optimization
##param-max-dse-active-local-stores compiler flag: --param max-dse-active-local-stores= (Maximum number of active local stores in RTL dead store elimination) integer 31280 --param max-dse-active-local-stores= 0 10000 1 basic, parametric, optimization
##param-prefetch-latency compiler flag: --param prefetch-latency= (The number of insns executed before prefetch is completed) integer 31290 --param prefetch-latency= 0 400 1 basic, parametric, optimization
##param-simultaneous-prefetches compiler flag: --param simultaneous-prefetches= (The number of prefetches that can run at the same time) integer 31300 --param simultaneous-prefetches= 0 6 1 basic, parametric, optimization
##param-l1-cache-size compiler flag: --param l1-cache-size= (The size of L1 cache) integer 31310 --param l1-cache-size= 0 128 1 basic, parametric, optimization
##param-l1-cache-line-size compiler flag: --param l1-cache-line-size= (The size of L1 cache line) integer 31320 --param l1-cache-line-size= 0 64 1 basic, parametric, optimization
##param-l2-cache-size compiler flag: --param l2-cache-size= (The size of L2 cache) integer 31330 --param l2-cache-size= 0 1024 1 basic, parametric, optimization
##param-use-canonical-types compiler flag: --param use-canonical-types= (Whether to use canonical types) integer 31340 --param use-canonical-types= 0 1 1 basic, parametric, optimization
##param-max-partial-antic-length compiler flag: --param max-partial-antic-length= (Maximum length of partial antic set when performing tree pre optimization) integer 31350 --param max-partial-antic-length= 0 200 1 basic, parametric, optimization
##param-sccvn-max-scc-size compiler flag: --param sccvn-max-scc-size= (Maximum size of a SCC before SCCVN stops processing a function) integer 31360 --param sccvn-max-scc-size= 0 20000 1 basic, parametric, optimization
##param-sccvn-max-alias-queries-per-access compiler flag: --param sccvn-max-alias-queries-per-access= (Maximum number of disambiguations to perform per memory access) integer 31370 --param sccvn-max-alias-queries-per-access= 0 2000 1 basic, parametric, optimization
##param-ira-max-loops-num compiler flag: --param ira-max-loops-num= (Max loops number for regional RA) integer 31380 --param ira-max-loops-num= 0 200 1 basic, parametric, optimization
##param-ira-max-conflict-table-size compiler flag: --param ira-max-conflict-table-size= (Max size of conflict table in MB) integer 31390 --param ira-max-conflict-table-size= 0 2000 1 basic, parametric, optimization
##param-ira-loop-reserved-regs compiler flag: --param ira-loop-reserved-regs= (The number of registers in each class kept unused by loop invariant motion) integer 31400 --param ira-loop-reserved-regs= 0 4 1 basic, parametric, optimization
##param-lra-max-considered-reload-pseudos compiler flag: --param lra-max-considered-reload-pseudos= (The max number of reload pseudos which are considered during spilling a non-reload pseudo) integer 31410 --param lra-max-considered-reload-pseudos= 0 1000 1 basic, parametric, optimization
##param-lra-inheritance-ebb-probability-cutoff compiler flag: --param lra-inheritance-ebb-probability-cutoff= (Minimal fall-through edge probability in percentage used to add BB to inheritance EBB in LRA) integer 31420 --param lra-inheritance-ebb-probability-cutoff= 0 100 1 basic, parametric, optimization
##param-switch-conversion-max-branch-ratio compiler flag: --param switch-conversion-max-branch-ratio= (The maximum ratio between array size and switch branches fora switch conversion to take place) integer 31430 --param switch-conversion-max-branch-ratio= 1 16 1 basic, parametric, optimization
##param-loop-block-tile-size compiler flag: --param loop-block-tile-size= (size of tiles for loop blocking) integer 31440 --param loop-block-tile-size= 0 102 1 basic, parametric, optimization
##param-graphite-max-nb-scop-params compiler flag: --param graphite-max-nb-scop-params= (maximum number of parameters in a SCoP) integer 31470 --param graphite-max-nb-scop-params= 0 20 1 basic, parametric, optimization
##param-graphite-max-bbs-per-function compiler flag: --param graphite-max-bbs-per-function= (maximum number of basic blocks per function to be analyzed by Graphite) integer 31480 --param graphite-max-bbs-per-function= 0 200 1 basic, parametric, optimization
##param-loop-max-datarefs-for-datadeps compiler flag: --param loop-max-datarefs-for-datadeps= (Maximum number of datarefs in loop for building loop data dependencies) integer 31490 --param loop-max-datarefs-for-datadeps= 0 2000 1 basic, parametric, optimization
##param-loop-invariant-max-bbs-in-loop compiler flag: --param loop-invariant-max-bbs-in-loop= (Max basic blocks number in loop for loop invariant motion) integer 31500 --param loop-invariant-max-bbs-in-loop= 0 20000 1 basic, parametric, optimization
##param-slp-max-insns-in-bb compiler flag: --param slp-max-insns-in-bb= (Maximum number of instructions in basic block to be considered for SLP vectorization) integer 31530 --param slp-max-insns-in-bb= 0 2000 1 basic, parametric, optimization
##param-min-insn-to-prefetch-ratio compiler flag: --param min-insn-to-prefetch-ratio= (Min. ratio of insns to prefetches to enable prefetching fora loop with an unknown trip count) integer 31540 --param min-insn-to-prefetch-ratio= 0 18 1 basic, parametric, optimization
##param-prefetch-min-insn-to-mem-ratio compiler flag: --param prefetch-min-insn-to-mem-ratio= (Min. ratio of insns to mem ops to enable prefetching in a loop) integer 31550 --param prefetch-min-insn-to-mem-ratio= 0 6 1 basic, parametric, optimization
##param-max-vartrack-size compiler flag: --param max-vartrack-size= (Max. size of var tracking hash tables) integer 31560 --param max-vartrack-size= 0 100000000 1 basic, parametric, optimization
##param-max-vartrack-expr-depth compiler flag: --param max-vartrack-expr-depth= (Max. recursion depth for expanding var tracking expressions) integer 31570 --param max-vartrack-expr-depth= 0 24 1 basic, parametric, optimization
##param-max-vartrack-reverse-op-size compiler flag: --param max-vartrack-reverse-op-size= (Max. size of loc list for which reverse ops should be added) integer 31580 --param max-vartrack-reverse-op-size= 0 100 1 basic, parametric, optimization
##param-ipa-sra-ptr-growth-factor compiler flag: --param ipa-sra-ptr-growth-factor= (Maximum allowed growth of size of new parameters ipa-sra replacesa pointer to an aggregate with) integer 31600 --param ipa-sra-ptr-growth-factor= 0 4 1 basic, parametric, optimization
##param-tm-max-aggregate-size compiler flag: --param tm-max-aggregate-size= (Size in bytes after which thread-local aggregates should beinstrumented with the logging functions instead of save/restorepairs) integer 31610 --param tm-max-aggregate-size= 0 18 1 basic, parametric, optimization
##param-sra-max-scalarization-size-Ospeed compiler flag: --param sra-max-scalarization-size-Ospeed= (Maximum size, in storage units, of an aggregate which should beconsidered for scalarization when compiling for speed) integer 31620 --param sra-max-scalarization-size-Ospeed= 0 0 1 basic, parametric, optimization
##param-sra-max-scalarization-size-Osize compiler flag: --param sra-max-scalarization-size-Osize= (Maximum size, in storage units, of an aggregate which should beconsidered for scalarization when compiling for size) integer 31630 --param sra-max-scalarization-size-Osize= 0 0 1 basic, parametric, optimization
##param-ipa-cp-value-list-size compiler flag: --param ipa-cp-value-list-size= (Maximum size of a list of values associated with each parameter forinterprocedural constant propagation) integer 31640 --param ipa-cp-value-list-size= 0 16 1 basic, parametric, optimization
##param-ipa-cp-eval-threshold compiler flag: --param ipa-cp-eval-threshold= (Threshold ipa-cp opportunity evaluation that is still consideredbeneficial to clone.) integer 31650 --param ipa-cp-eval-threshold= 0 1000 1 basic, parametric, optimization
##param-ipa-cp-recursion-penalty compiler flag: --param ipa-cp-recursion-penalty= (Percentage penalty the recursive functions will receive when theyare evaluated for cloning.) integer 31660 --param ipa-cp-recursion-penalty= 0 100 1 basic, parametric, optimization
##param-ipa-cp-single-call-penalty compiler flag: --param ipa-cp-single-call-penalty= (Percentage penalty functions containg a single call to anotherfunction will receive when they are evaluated for cloning.) integer 31670 --param ipa-cp-single-call-penalty= 0 100 1 basic, parametric, optimization
##param-ipa-max-agg-items compiler flag: --param ipa-max-agg-items= (Maximum number of aggregate content items for a parameter injump functions and lattices) integer 31680 --param ipa-max-agg-items= 0 32 1 basic, parametric, optimization
##param-ipa-cp-loop-hint-bonus compiler flag: --param ipa-cp-loop-hint-bonus= (Compile-time bonus IPA-CP assigns to candidates which make loopbounds or strides known.) integer 31690 --param ipa-cp-loop-hint-bonus= 0 128 1 basic, parametric, optimization
##param-ipa-cp-array-index-hint-bonus compiler flag: --param ipa-cp-array-index-hint-bonus= (Compile-time bonus IPA-CP assigns to candidates which make an arrayindex known.) integer 31700 --param ipa-cp-array-index-hint-bonus= 0 96 1 basic, parametric, optimization
##param-ipa-max-aa-steps compiler flag: --param ipa-max-aa-steps= (Maximum number of statements that will be visited by IPA formalparameter analysis based on alias analysis in any given function) integer 31710 --param ipa-max-aa-steps= 0 50000 1 basic, parametric, optimization
##param-lto-partitions compiler flag: --param lto-partitions= (Number of partitions the program should be split to) integer 31720 --param lto-partitions= 0 64 1 basic, parametric, optimization
##param-lto-min-partition compiler flag: --param lto-min-partition= (Minimal size of a partition for LTO (in estimated instructions)) integer 31730 --param lto-min-partition= 0 2000 1 basic, parametric, optimization
##param-cxx-max-namespaces-for-diagnostic-help compiler flag: --param cxx-max-namespaces-for-diagnostic-help= (Maximum number of namespaces to search for alternatives whenname lookup fails) integer 31740 --param cxx-max-namespaces-for-diagnostic-help= 0 2000 1 basic, parametric, optimization
##param-max-stores-to-sink compiler flag: --param max-stores-to-sink= (Maximum number of conditional store pairs that can be sunk) integer 31750 --param max-stores-to-sink= 0 4 1 basic, parametric, optimization
##param-case-values-threshold compiler flag: --param case-values-threshold= (The smallest number of different values for which it is best touse a jump-table instead of a tree of conditional branches,if 0, use the default for the machine) integer 31760 --param case-values-threshold= 0 0 1 basic, parametric, optimization
##param-allow-store-data-races compiler flag: --param allow-store-data-races= (Allow new data races on stores to be introduced) integer 31770 --param allow-store-data-races= 0 1 1 basic, parametric, optimization
##param-tree-reassoc-width compiler flag: --param tree-reassoc-width= (Set the maximum number of instructions executed in parallel inreassociated tree. If 0, use the target dependent heuristic.) integer 31780 --param tree-reassoc-width= 0 0 1 basic, parametric, optimization
##param-max-tail-merge-comparisons compiler flag: --param max-tail-merge-comparisons= (Maximum amount of similar bbs to compare a bb with) integer 31790 --param max-tail-merge-comparisons= 0 20 1 basic, parametric, optimization
##param-max-tail-merge-iterations compiler flag: --param max-tail-merge-iterations= (Maximum amount of iterations of the pass over a function) integer 31800 --param max-tail-merge-iterations= 0 4 1 basic, parametric, optimization
##param-max-tracked-strlens compiler flag: --param max-tracked-strlens= (Maximum number of strings for which strlen optimization pass willtrack string lengths) integer 31810 --param max-tracked-strlens= 0 20000 1 basic, parametric, optimization
##param-sched-pressure-algorithm compiler flag: --param sched-pressure-algorithm= (Which -fsched-pressure algorithm to apply) integer 31820 --param sched-pressure-algorithm= 1 2 1 basic, parametric, optimization
##param-max-slsr-cand-scan compiler flag: --param max-slsr-cand-scan= (Maximum length of candidate scans for straight-linestrength reduction) integer 31830 --param max-slsr-cand-scan= 1 999999 1 basic, parametric, optimization
##param-asan-stack compiler flag: --param asan-stack= (Enable asan stack protection) integer 31840 --param asan-stack= 0 1 1 basic, parametric, optimization
##param-asan-globals compiler flag: --param asan-globals= (Enable asan globals protection) integer 31850 --param asan-globals= 0 1 1 basic, parametric, optimization
##param-asan-instrument-writes compiler flag: --param asan-instrument-writes= (Enable asan store operations protection) integer 31860 --param asan-instrument-writes= 0 1 1 basic, parametric, optimization
##param-asan-instrument-reads compiler flag: --param asan-instrument-reads= (Enable asan load operations protection) integer 31870 --param asan-instrument-reads= 0 1 1 basic, parametric, optimization
##param-asan-memintrin compiler flag: --param asan-memintrin= (Enable asan builtin functions protection) integer 31880 --param asan-memintrin= 0 1 1 basic, parametric, optimization
##param-asan-use-after-return compiler flag: --param asan-use-after-return= (Enable asan detection of use-after-return bugs) integer 31890 --param asan-use-after-return= 0 1 1 basic, parametric, optimization
##param-uninit-control-dep-attempts compiler flag: --param uninit-control-dep-attempts= (Maximum number of nested calls to search for control dependenciesduring uninitialized variable analysis) integer 31910 --param uninit-control-dep-attempts= 1 2000 1 basic, parametric, optimization
##param-chkp-max-ctor-size compiler flag: --param chkp-max-ctor-size= (Maximum number of statements to be included into a single staticconstructor generated by Pointer Bounds Checker) integer 31920 --param chkp-max-ctor-size= 100 10000 10 basic, parametric, optimization
##param-max-fsm-thread-path-insns compiler flag: --param max-fsm-thread-path-insns= (Maximum number of instructions to copy when duplicating blocks on a finite state automaton jump thread path) integer 31930 --param max-fsm-thread-path-insns= 1 999999 1 basic, parametric, optimization
##param-max-fsm-thread-length compiler flag: --param max-fsm-thread-length= (Maximum number of basic blocks on a finite state automaton jump thread path) integer 31940 --param max-fsm-thread-length= 1 999999 1 basic, parametric, optimization
##param-max-fsm-thread-paths compiler flag: --param max-fsm-thread-paths= (Maximum number of new jump thread paths to create for a finite state automaton) integer 31950 --param max-fsm-thread-paths= 1 999999 1 basic, parametric, optimization

View entry in raw format

Developed by dividiti,
cTuning foundation,
and the community
          
Implemented as a CK workflow
                     
   
   
                      Hosted at