Mercurial > hg > CbC > CbC_gcc

comparison gcc/params.def @ 131:84e7813d76e9

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
gcc-8.2
author mir3636
date Thu, 25 Oct 2018 07:37:49 +0900
parents 04ced10e8804
children
comparison
equal deleted inserted replaced
111:04ced10e8804 131:84e7813d76e9
1 /* params.def - Run-time parameters. 1 /* params.def - Run-time parameters.
2 Copyright (C) 2001-2017 Free Software Foundation, Inc. 2 Copyright (C) 2001-2018 Free Software Foundation, Inc.
3 Written by Mark Mitchell <mark@codesourcery.com>. 3 Written by Mark Mitchell <mark@codesourcery.com>.
4 4
5 This file is part of GCC. 5 This file is part of GCC.
6 6
7 GCC is free software; you can redistribute it and/or modify it under 7 GCC is free software; you can redistribute it and/or modify it under
50 2, 0, 50) 50 2, 0, 50)
51 51
52 DEFPARAM (PARAM_INLINE_MIN_SPEEDUP, 52 DEFPARAM (PARAM_INLINE_MIN_SPEEDUP,
53 "inline-min-speedup", 53 "inline-min-speedup",
54 "The minimal estimated speedup allowing inliner to ignore inline-insns-single and inline-insns-auto.", 54 "The minimal estimated speedup allowing inliner to ignore inline-insns-single and inline-insns-auto.",
55 8, 0, 0) 55 15, 0, 0)
56 56
57 /* The single function inlining limit. This is the maximum size 57 /* The single function inlining limit. This is the maximum size
58 of a function counted in internal gcc instructions (not in 58 of a function counted in internal gcc instructions (not in
59 real machine instructions) that is eligible for inlining 59 real machine instructions) that is eligible for inlining
60 by the tree inliner. 60 by the tree inliner.
61 The default value is 450. 61 The default value is 400.
62 Only functions marked inline (or methods defined in the class 62 Only functions marked inline (or methods defined in the class
63 definition for C++) are affected by this. 63 definition for C++) are affected by this.
64 There are more restrictions to inlining: If inlined functions 64 There are more restrictions to inlining: If inlined functions
65 call other functions, the already inlined instructions are 65 call other functions, the already inlined instructions are
66 counted and once the recursive inline limit (see 66 counted and once the recursive inline limit (see
75 inlined by virtue of -finline-functions (-O3). 75 inlined by virtue of -finline-functions (-O3).
76 This limit should be chosen to be below or equal to the limit 76 This limit should be chosen to be below or equal to the limit
77 that is applied to functions marked inlined (or defined in the 77 that is applied to functions marked inlined (or defined in the
78 class declaration in C++) given by the "max-inline-insns-single" 78 class declaration in C++) given by the "max-inline-insns-single"
79 parameter. 79 parameter.
80 The default value is 40. */ 80 The default value is 30. */
81 DEFPARAM (PARAM_MAX_INLINE_INSNS_AUTO, 81 DEFPARAM (PARAM_MAX_INLINE_INSNS_AUTO,
82 "max-inline-insns-auto", 82 "max-inline-insns-auto",
83 "The maximum number of instructions when automatically inlining.", 83 "The maximum number of instructions when automatically inlining.",
84 40, 0, 0) 84 30, 0, 0)
85 85
86 DEFPARAM (PARAM_MAX_INLINE_INSNS_RECURSIVE, 86 DEFPARAM (PARAM_MAX_INLINE_INSNS_RECURSIVE,
87 "max-inline-insns-recursive", 87 "max-inline-insns-recursive",
88 "The maximum number of instructions inline function can grow to via recursive inlining.", 88 "The maximum number of instructions inline function can grow to via recursive inlining.",
89 450, 0, 0) 89 450, 0, 0)
137 137
138 /* Limit loop autovectorization to loops with large enough iteration count. */ 138 /* Limit loop autovectorization to loops with large enough iteration count. */
139 DEFPARAM (PARAM_MIN_VECT_LOOP_BOUND, 139 DEFPARAM (PARAM_MIN_VECT_LOOP_BOUND,
140 "min-vect-loop-bound", 140 "min-vect-loop-bound",
141 "If -ftree-vectorize is used, the minimal loop bound of a loop to be considered for vectorization.", 141 "If -ftree-vectorize is used, the minimal loop bound of a loop to be considered for vectorization.",
142 1, 1, 0) 142 0, 0, 0)
143 143
144 /* The maximum number of instructions to consider when looking for an 144 /* The maximum number of instructions to consider when looking for an
145 instruction to fill a delay slot. If more than this arbitrary 145 instruction to fill a delay slot. If more than this arbitrary
146 number of instructions is searched, the time savings from filling 146 number of instructions is searched, the time savings from filling
147 the delay slot will be minimal so stop searching. Increasing 147 the delay slot will be minimal so stop searching. Increasing
211 DEFPARAM(PARAM_STACK_FRAME_GROWTH, 211 DEFPARAM(PARAM_STACK_FRAME_GROWTH,
212 "large-stack-frame-growth", 212 "large-stack-frame-growth",
213 "Maximal stack frame growth due to inlining (in percent).", 213 "Maximal stack frame growth due to inlining (in percent).",
214 1000, 0, 0) 214 1000, 0, 0)
215 215
216 /* Keep these up to date with those in configure.ac. */
216 DEFPARAM(PARAM_STACK_CLASH_PROTECTION_GUARD_SIZE, 217 DEFPARAM(PARAM_STACK_CLASH_PROTECTION_GUARD_SIZE,
217 "stack-clash-protection-guard-size", 218 "stack-clash-protection-guard-size",
218 "Size of the stack guard expressed as a power of two.", 219 "Size of the stack guard expressed as a power of two in bytes.",
219 12, 12, 30) 220 12, 12, 30)
220 221
221 DEFPARAM(PARAM_STACK_CLASH_PROTECTION_PROBE_INTERVAL, 222 DEFPARAM(PARAM_STACK_CLASH_PROTECTION_PROBE_INTERVAL,
222 "stack-clash-protection-probe-interval", 223 "stack-clash-protection-probe-interval",
223 "Interval in which to probe the stack expressed as a power of two.", 224 "Interval in which to probe the stack expressed as a power of two in bytes.",
224 12, 10, 16) 225 12, 10, 16)
225 226
226 /* The GCSE optimization will be disabled if it would require 227 /* The GCSE optimization will be disabled if it would require
227 significantly more memory than this value. */ 228 significantly more memory than this value. */
228 DEFPARAM(PARAM_MAX_GCSE_MEMORY, 229 DEFPARAM(PARAM_MAX_GCSE_MEMORY,
352 DEFPARAM(PARAM_MAX_UNSWITCH_LEVEL, 353 DEFPARAM(PARAM_MAX_UNSWITCH_LEVEL,
353 "max-unswitch-level", 354 "max-unswitch-level",
354 "The maximum number of unswitchings in a single loop.", 355 "The maximum number of unswitchings in a single loop.",
355 3, 0, 0) 356 3, 0, 0)
356 357
357 /* The maximum number of insns in loop header duplicated by he copy loop 358 /* The maximum number of insns in loop header duplicated by the copy loop
358 headers pass. */ 359 headers pass. */
359 DEFPARAM(PARAM_MAX_LOOP_HEADER_INSNS, 360 DEFPARAM(PARAM_MAX_LOOP_HEADER_INSNS,
360 "max-loop-header-insns", 361 "max-loop-header-insns",
361 "The maximum number of insns in loop header duplicated by he copy loop headers pass.", 362 "The maximum number of insns in loop header duplicated by the copy loop headers pass.",
362 20, 0, 0) 363 20, 0, 0)
363 364
364 /* The maximum number of iterations of a loop the brute force algorithm 365 /* The maximum number of iterations of a loop the brute force algorithm
365 for analysis of # of iterations of the loop tries to evaluate. */ 366 for analysis of # of iterations of the loop tries to evaluate. */
366 DEFPARAM(PARAM_MAX_ITERATIONS_TO_TRACK, 367 DEFPARAM(PARAM_MAX_ITERATIONS_TO_TRACK,
391 DEFPARAM(PARAM_SMS_LOOP_AVERAGE_COUNT_THRESHOLD, 392 DEFPARAM(PARAM_SMS_LOOP_AVERAGE_COUNT_THRESHOLD,
392 "sms-loop-average-count-threshold", 393 "sms-loop-average-count-threshold",
393 "A threshold on the average loop count considered by the swing modulo scheduler.", 394 "A threshold on the average loop count considered by the swing modulo scheduler.",
394 0, 0, 0) 395 0, 0, 0)
395 396
397 DEFPARAM(HOT_BB_COUNT_FRACTION,
398 "hot-bb-count-fraction",
399 "Select fraction of the maximal count of repetitions of basic block in program given basic "
400 "block needs to have to be considered hot (used in non-LTO mode)",
401 10000, 0, 0)
396 DEFPARAM(HOT_BB_COUNT_WS_PERMILLE, 402 DEFPARAM(HOT_BB_COUNT_WS_PERMILLE,
397 "hot-bb-count-ws-permille", 403 "hot-bb-count-ws-permille",
398 "A basic block profile count is considered hot if it contributes to " 404 "A basic block profile count is considered hot if it contributes to "
399 "the given permillage of the entire profiled execution.", 405 "the given permillage of the entire profiled execution (used in LTO mode).",
400 999, 0, 1000) 406 999, 0, 1000)
401 DEFPARAM(HOT_BB_FREQUENCY_FRACTION, 407 DEFPARAM(HOT_BB_FREQUENCY_FRACTION,
402 "hot-bb-frequency-fraction", 408 "hot-bb-frequency-fraction",
403 "Select fraction of the maximal frequency of executions of basic block in function given basic block needs to have to be considered hot.", 409 "Select fraction of the maximal frequency of executions of basic block in function given basic block needs to have to be considered hot.",
404 1000, 0, 0) 410 1000, 0, 0)
413 "Select fraction of the maximal frequency of executions of basic block in function given basic block get alignment.", 419 "Select fraction of the maximal frequency of executions of basic block in function given basic block get alignment.",
414 100, 1, 0) 420 100, 1, 0)
415 421
416 DEFPARAM (PARAM_ALIGN_LOOP_ITERATIONS, 422 DEFPARAM (PARAM_ALIGN_LOOP_ITERATIONS,
417 "align-loop-iterations", 423 "align-loop-iterations",
418 "Loops iterating at least selected number of iterations will get loop alignment..", 424 "Loops iterating at least selected number of iterations will get "
419 4, 0, 0) 425 "loop alignment.", 4, 0, 0)
420 426
421 /* For guessed profiles, the loops having unknown number of iterations 427 /* For guessed profiles, the loops having unknown number of iterations
422 are predicted to iterate relatively few (10) times at average. 428 are predicted to iterate relatively few (10) times at average.
423 For functions containing one loop with large known number of iterations 429 For functions containing one loop with large known number of iterations
424 and other loops having unbounded loops we would end up predicting all 430 and other loops having unbounded loops we would end up predicting all
444 450
445 DEFPARAM(BUILTIN_EXPECT_PROBABILITY, 451 DEFPARAM(BUILTIN_EXPECT_PROBABILITY,
446 "builtin-expect-probability", 452 "builtin-expect-probability",
447 "Set the estimated probability in percentage for builtin expect. The default value is 90% probability.", 453 "Set the estimated probability in percentage for builtin expect. The default value is 90% probability.",
448 90, 0, 100) 454 90, 0, 100)
455 DEFPARAM(BUILTIN_STRING_CMP_INLINE_LENGTH,
456 "builtin-string-cmp-inline-length",
457 "The maximum length of a constant string for a builtin string cmp call eligible for inlining. The default value is 3.",
458 3, 0, 100)
449 DEFPARAM(TRACER_DYNAMIC_COVERAGE_FEEDBACK, 459 DEFPARAM(TRACER_DYNAMIC_COVERAGE_FEEDBACK,
450 "tracer-dynamic-coverage-feedback", 460 "tracer-dynamic-coverage-feedback",
451 "The percentage of function, weighted by execution frequency, that must be covered by trace formation. Used when profile feedback is available.", 461 "The percentage of function, weighted by execution frequency, that must be covered by trace formation. Used when profile feedback is available.",
452 95, 0, 100) 462 95, 0, 100)
453 DEFPARAM(TRACER_DYNAMIC_COVERAGE, 463 DEFPARAM(TRACER_DYNAMIC_COVERAGE,
545 DEFPARAM(PARAM_DSE_MAX_OBJECT_SIZE, 555 DEFPARAM(PARAM_DSE_MAX_OBJECT_SIZE,
546 "dse-max-object-size", 556 "dse-max-object-size",
547 "Maximum size (in bytes) of objects tracked bytewise by dead store elimination.", 557 "Maximum size (in bytes) of objects tracked bytewise by dead store elimination.",
548 256, 0, 0) 558 256, 0, 0)
549 559
560 DEFPARAM(PARAM_DSE_MAX_ALIAS_QUERIES_PER_STORE,
561 "dse-max-alias-queries-per-store",
562 "Maximum number of queries into the alias oracle per store.",
563 256, 0, 0)
564
550 DEFPARAM(PARAM_SCEV_MAX_EXPR_SIZE, 565 DEFPARAM(PARAM_SCEV_MAX_EXPR_SIZE,
551 "scev-max-expr-size", 566 "scev-max-expr-size",
552 "Bound on size of expressions used in the scalar evolutions analyzer.", 567 "Bound on size of expressions used in the scalar evolutions analyzer.",
553 100, 0, 0) 568 100, 0, 0)
554 569
742 0, 0, 0) 757 0, 0, 0)
743 758
744 DEFPARAM(PARAM_MAX_SCHED_READY_INSNS, 759 DEFPARAM(PARAM_MAX_SCHED_READY_INSNS,
745 "max-sched-ready-insns", 760 "max-sched-ready-insns",
746 "The maximum number of instructions ready to be issued to be considered by the scheduler during the first scheduling pass.", 761 "The maximum number of instructions ready to be issued to be considered by the scheduler during the first scheduling pass.",
747 100, 0, 0) 762 100, 1, 0)
748 763
749 /* This is the maximum number of active local stores RTL DSE will consider. */ 764 /* This is the maximum number of active local stores RTL DSE will consider. */
750 DEFPARAM (PARAM_MAX_DSE_ACTIVE_LOCAL_STORES, 765 DEFPARAM (PARAM_MAX_DSE_ACTIVE_LOCAL_STORES,
751 "max-dse-active-local-stores", 766 "max-dse-active-local-stores",
752 "Maximum number of active local stores in RTL dead store elimination.", 767 "Maximum number of active local stores in RTL dead store elimination.",
788 DEFPARAM (PARAM_L2_CACHE_SIZE, 803 DEFPARAM (PARAM_L2_CACHE_SIZE,
789 "l2-cache-size", 804 "l2-cache-size",
790 "The size of L2 cache.", 805 "The size of L2 cache.",
791 512, 0, 0) 806 512, 0, 0)
792 807
808 /* Whether software prefetch hints should be issued for non-constant
809 strides. */
810
811 DEFPARAM (PARAM_PREFETCH_DYNAMIC_STRIDES,
812 "prefetch-dynamic-strides",
813 "Whether software prefetch hints should be issued for non-constant "
814 "strides.",
815 1, 0, 1)
816
817 /* The minimum constant stride beyond which we should use prefetch hints
818 for. */
819
820 DEFPARAM (PARAM_PREFETCH_MINIMUM_STRIDE,
821 "prefetch-minimum-stride",
822 "The minimum constant stride beyond which we should use prefetch "
823 "hints for.",
824 -1, 0, 0)
825
826 /* Maximum number of statements in loop nest for loop interchange. */
827
828 DEFPARAM (PARAM_LOOP_INTERCHANGE_MAX_NUM_STMTS,
829 "loop-interchange-max-num-stmts",
830 "The maximum number of stmts in loop nest for loop interchange.",
831 64, 0, 0)
832
833 /* Minimum stride ratio for loop interchange to be profitiable. */
834
835 DEFPARAM (PARAM_LOOP_INTERCHANGE_STRIDE_RATIO,
836 "loop-interchange-stride-ratio",
837 "The minimum stride ratio for loop interchange to be profitable.",
838 2, 0, 0)
839
793 /* Whether we should use canonical types rather than deep "structural" 840 /* Whether we should use canonical types rather than deep "structural"
794 type checking. Setting this value to 1 (the default) improves 841 type checking. Setting this value to 1 (the default) improves
795 compilation performance in the C++ and Objective-C++ front end; 842 compilation performance in the C++ and Objective-C++ front end;
796 this value should only be set to zero to work around bugs in the 843 this value should only be set to zero to work around bugs in the
797 canonical type system by disabling it. */ 844 canonical type system by disabling it. */
804 DEFPARAM (PARAM_MAX_PARTIAL_ANTIC_LENGTH, 851 DEFPARAM (PARAM_MAX_PARTIAL_ANTIC_LENGTH,
805 "max-partial-antic-length", 852 "max-partial-antic-length",
806 "Maximum length of partial antic set when performing tree pre optimization.", 853 "Maximum length of partial antic set when performing tree pre optimization.",
807 100, 0, 0) 854 100, 0, 0)
808 855
809 /* The following is used as a stop-gap limit for cases where really huge 856 /* The following is used as a stop-gap limit for cases where really deep
810 SCCs blow up memory and compile-time use too much. If we hit this limit, 857 loop nests cause compile-time to blow up. If we hit this limit,
811 SCCVN and such FRE and PRE will be not done at all for the current 858 FRE and PRE will value-number outer loops (but the outermost) in a
812 function. */ 859 loop nest non-optimistically. */
813 860
814 DEFPARAM (PARAM_SCCVN_MAX_SCC_SIZE, 861 DEFPARAM (PARAM_RPO_VN_MAX_LOOP_DEPTH,
815 "sccvn-max-scc-size", 862 "rpo-vn-max-loop-depth",
816 "Maximum size of a SCC before SCCVN stops processing a function.", 863 "Maximum depth of a loop nest to fully value-number optimistically.",
817 10000, 10, 0) 864 7, 2, 0)
818 865
819 /* The following is used as a stop-gap limit for cases where really huge 866 /* The following is used as a stop-gap limit for cases where really huge
820 functions blow up compile-time use too much. It limits the number of 867 functions blow up compile-time use too much. It limits the number of
821 alias-queries we do for finding common subexpressions for memory loads and 868 alias-queries we do for finding common subexpressions for memory loads and
822 stores. The number of alias-queries is otherwise limited by the number of 869 stores. The number of alias-queries is otherwise limited by the number of
863 910
864 /* Size of tiles when doing loop blocking. */ 911 /* Size of tiles when doing loop blocking. */
865 912
866 DEFPARAM (PARAM_LOOP_BLOCK_TILE_SIZE, 913 DEFPARAM (PARAM_LOOP_BLOCK_TILE_SIZE,
867 "loop-block-tile-size", 914 "loop-block-tile-size",
868 "size of tiles for loop blocking.", 915 "Size of tiles for loop blocking.",
869 51, 0, 0) 916 51, 0, 0)
870 917
871 /* Maximal number of parameters that we allow in a SCoP. */ 918 /* Maximal number of parameters that we allow in a SCoP. */
872 919
873 DEFPARAM (PARAM_GRAPHITE_MAX_NB_SCOP_PARAMS, 920 DEFPARAM (PARAM_GRAPHITE_MAX_NB_SCOP_PARAMS,
874 "graphite-max-nb-scop-params", 921 "graphite-max-nb-scop-params",
875 "maximum number of parameters in a SCoP.", 922 "Maximum number of parameters in a SCoP.",
876 10, 0, 0) 923 10, 0, 0)
877 924
878 /* Maximal number of array references in a scop. */ 925 /* Maximal number of array references in a scop. */
879 926
880 DEFPARAM (PARAM_GRAPHITE_MAX_ARRAYS_PER_SCOP, 927 DEFPARAM (PARAM_GRAPHITE_MAX_ARRAYS_PER_SCOP,
881 "graphite-max-arrays-per-scop", 928 "graphite-max-arrays-per-scop",
882 "maximum number of arrays per scop.", 929 "Maximum number of arrays per scop.",
883 100, 0, 0) 930 100, 0, 0)
884 931
885 DEFPARAM (PARAM_MAX_ISL_OPERATIONS, 932 DEFPARAM (PARAM_MAX_ISL_OPERATIONS,
886 "max-isl-operations", 933 "max-isl-operations",
887 "maximum number of isl operations, 0 means unlimited", 934 "Maximum number of isl operations, 0 means unlimited.",
888 350000, 0, 0) 935 350000, 0, 0)
889 936
890 /* For testsuite purposes allow to check for codegen error handling. */ 937 /* For testsuite purposes allow to check for codegen error handling. */
891 DEFPARAM (PARAM_GRAPHITE_ALLOW_CODEGEN_ERRORS, 938 DEFPARAM (PARAM_GRAPHITE_ALLOW_CODEGEN_ERRORS,
892 "graphite-allow-codegen-errors", 939 "graphite-allow-codegen-errors",
893 "whether codegen errors should be ICEs when -fchecking.", 940 "Whether codegen errors should be ICEs when -fchecking.",
894 0, 0, 1) 941 0, 0, 1)
895 942
896 /* Avoid data dependence analysis on very large loops. */ 943 /* Avoid data dependence analysis on very large loops. */
897 DEFPARAM (PARAM_LOOP_MAX_DATAREFS_FOR_DATADEPS, 944 DEFPARAM (PARAM_LOOP_MAX_DATAREFS_FOR_DATADEPS,
898 "loop-max-datarefs-for-datadeps", 945 "loop-max-datarefs-for-datadeps",
908 955
909 /* When the parameter is 1, use the internal function id 956 /* When the parameter is 1, use the internal function id
910 to look up for profile data. Otherwise, use a more stable 957 to look up for profile data. Otherwise, use a more stable
911 external id based on assembler name and source location. */ 958 external id based on assembler name and source location. */
912 DEFPARAM (PARAM_PROFILE_FUNC_INTERNAL_ID, 959 DEFPARAM (PARAM_PROFILE_FUNC_INTERNAL_ID,
913 "profile-func-internal-id", 960 "profile-func-internal-id",
914 "use internal function id in profile lookup.", 961 "Use internal function id in profile lookup.",
915 0, 0, 1) 962 0, 0, 1)
916 963
917 /* When the parameter is 1, track the most frequent N target 964 /* When the parameter is 1, track the most frequent N target
918 addresses in indirect-call profile. This disables 965 addresses in indirect-call profile. This disables
919 indirect_call_profiler_v2 which tracks single target. */ 966 indirect_call_profiler_v2 which tracks single target. */
920 DEFPARAM (PARAM_INDIR_CALL_TOPN_PROFILE, 967 DEFPARAM (PARAM_INDIR_CALL_TOPN_PROFILE,
921 "indir-call-topn-profile", 968 "indir-call-topn-profile",
922 "track topn target addresses in indirect-call profile.", 969 "Track top N target addresses in indirect-call profile.",
923 0, 0, 1) 970 0, 0, 1)
924 971
925 /* Avoid SLP vectorization of large basic blocks. */ 972 /* Avoid SLP vectorization of large basic blocks. */
926 DEFPARAM (PARAM_SLP_MAX_INSNS_IN_BB, 973 DEFPARAM (PARAM_SLP_MAX_INSNS_IN_BB,
927 "slp-max-insns-in-bb", 974 "slp-max-insns-in-bb",
928 "Maximum number of instructions in basic block to be considered for SLP vectorization.", 975 "Maximum number of instructions in basic block to be considered for "
929 1000, 0, 0) 976 "SLP vectorization.", 1000, 0, 0)
930 977
931 DEFPARAM (PARAM_MIN_INSN_TO_PREFETCH_RATIO, 978 DEFPARAM (PARAM_MIN_INSN_TO_PREFETCH_RATIO,
932 "min-insn-to-prefetch-ratio", 979 "min-insn-to-prefetch-ratio",
933 "Min. ratio of insns to prefetches to enable prefetching for " 980 "Min. ratio of insns to prefetches to enable prefetching for "
934 "a loop with an unknown trip count.", 981 "a loop with an unknown trip count.",
960 DEFPARAM (PARAM_MAX_VARTRACK_REVERSE_OP_SIZE, 1007 DEFPARAM (PARAM_MAX_VARTRACK_REVERSE_OP_SIZE,
961 "max-vartrack-reverse-op-size", 1008 "max-vartrack-reverse-op-size",
962 "Max. size of loc list for which reverse ops should be added.", 1009 "Max. size of loc list for which reverse ops should be added.",
963 50, 0, 0) 1010 50, 0, 0)
964 1011
1012 /* Set a threshold to discard debug markers (e.g. debug begin stmt
1013 markers) when expanding a function to RTL, or inlining it into
1014 another function. */
1015
1016 DEFPARAM (PARAM_MAX_DEBUG_MARKER_COUNT,
1017 "max-debug-marker-count",
1018 "Max. count of debug markers to expand or inline.",
1019 100000, 0, 0)
1020
965 /* Set minimum insn uid for non-debug insns. */ 1021 /* Set minimum insn uid for non-debug insns. */
966 1022
967 DEFPARAM (PARAM_MIN_NONDEBUG_INSN_UID, 1023 DEFPARAM (PARAM_MIN_NONDEBUG_INSN_UID,
968 "min-nondebug-insn-uid", 1024 "min-nondebug-insn-uid",
969 "The minimum UID to be used for a nondebug insn.", 1025 "The minimum UID to be used for a nondebug insn.",
970 0, 0, 0) 1026 0, 0, 0)
971 1027
972 DEFPARAM (PARAM_IPA_SRA_PTR_GROWTH_FACTOR, 1028 DEFPARAM (PARAM_IPA_SRA_PTR_GROWTH_FACTOR,
973 "ipa-sra-ptr-growth-factor", 1029 "ipa-sra-ptr-growth-factor",
974 "Maximum allowed growth of size of new parameters ipa-sra replaces " 1030 "Maximum allowed growth of number and total size of new parameters "
975 "a pointer to an aggregate with.", 1031 "that ipa-sra replaces a pointer to an aggregate with.",
976 2, 0, 0) 1032 2, 0, 0)
977 1033
978 DEFPARAM (PARAM_TM_MAX_AGGREGATE_SIZE, 1034 DEFPARAM (PARAM_TM_MAX_AGGREGATE_SIZE,
979 "tm-max-aggregate-size", 1035 "tm-max-aggregate-size",
980 "Size in bytes after which thread-local aggregates should be " 1036 "Size in bytes after which thread-local aggregates should be "
1001 8, 0, 0) 1057 8, 0, 0)
1002 1058
1003 DEFPARAM (PARAM_IPA_CP_EVAL_THRESHOLD, 1059 DEFPARAM (PARAM_IPA_CP_EVAL_THRESHOLD,
1004 "ipa-cp-eval-threshold", 1060 "ipa-cp-eval-threshold",
1005 "Threshold ipa-cp opportunity evaluation that is still considered " 1061 "Threshold ipa-cp opportunity evaluation that is still considered "
1006 "beneficial to clone..", 1062 "beneficial to clone.",
1007 500, 0, 0) 1063 500, 0, 0)
1008 1064
1009 DEFPARAM (PARAM_IPA_CP_RECURSION_PENALTY, 1065 DEFPARAM (PARAM_IPA_CP_RECURSION_PENALTY,
1010 "ipa-cp-recursion-penalty", 1066 "ipa-cp-recursion-penalty",
1011 "Percentage penalty the recursive functions will receive when they " 1067 "Percentage penalty the recursive functions will receive when they "
1012 "are evaluated for cloning..", 1068 "are evaluated for cloning.",
1013 40, 0, 100) 1069 40, 0, 100)
1014 1070
1015 DEFPARAM (PARAM_IPA_CP_SINGLE_CALL_PENALTY, 1071 DEFPARAM (PARAM_IPA_CP_SINGLE_CALL_PENALTY,
1016 "ipa-cp-single-call-penalty", 1072 "ipa-cp-single-call-penalty",
1017 "Percentage penalty functions containing a single call to another " 1073 "Percentage penalty functions containing a single call to another "
1018 "function will receive when they are evaluated for cloning..", 1074 "function will receive when they are evaluated for cloning.",
1019 15, 0, 100) 1075 15, 0, 100)
1020 1076
1021 DEFPARAM (PARAM_IPA_MAX_AGG_ITEMS, 1077 DEFPARAM (PARAM_IPA_MAX_AGG_ITEMS,
1022 "ipa-max-agg-items", 1078 "ipa-max-agg-items",
1023 "Maximum number of aggregate content items for a parameter in " 1079 "Maximum number of aggregate content items for a parameter in "
1025 16, 0, 0) 1081 16, 0, 0)
1026 1082
1027 DEFPARAM (PARAM_IPA_CP_LOOP_HINT_BONUS, 1083 DEFPARAM (PARAM_IPA_CP_LOOP_HINT_BONUS,
1028 "ipa-cp-loop-hint-bonus", 1084 "ipa-cp-loop-hint-bonus",
1029 "Compile-time bonus IPA-CP assigns to candidates which make loop " 1085 "Compile-time bonus IPA-CP assigns to candidates which make loop "
1030 "bounds or strides known..", 1086 "bounds or strides known.",
1031 64, 0, 0) 1087 64, 0, 0)
1032 1088
1033 DEFPARAM (PARAM_IPA_CP_ARRAY_INDEX_HINT_BONUS, 1089 DEFPARAM (PARAM_IPA_CP_ARRAY_INDEX_HINT_BONUS,
1034 "ipa-cp-array-index-hint-bonus", 1090 "ipa-cp-array-index-hint-bonus",
1035 "Compile-time bonus IPA-CP assigns to candidates which make an array " 1091 "Compile-time bonus IPA-CP assigns to candidates which make an array "
1036 "index known..", 1092 "index known.",
1037 48, 0, 0) 1093 48, 0, 0)
1038 1094
1039 DEFPARAM (PARAM_IPA_MAX_AA_STEPS, 1095 DEFPARAM (PARAM_IPA_MAX_AA_STEPS,
1040 "ipa-max-aa-steps", 1096 "ipa-max-aa-steps",
1041 "Maximum number of statements that will be visited by IPA formal " 1097 "Maximum number of statements that will be visited by IPA formal "
1091 1147
1092 /* Reassociation width to be used by tree reassoc optimization. */ 1148 /* Reassociation width to be used by tree reassoc optimization. */
1093 DEFPARAM (PARAM_TREE_REASSOC_WIDTH, 1149 DEFPARAM (PARAM_TREE_REASSOC_WIDTH,
1094 "tree-reassoc-width", 1150 "tree-reassoc-width",
1095 "Set the maximum number of instructions executed in parallel in " 1151 "Set the maximum number of instructions executed in parallel in "
1096 "reassociated tree. If 0, use the target dependent heuristic..", 1152 "reassociated tree. If 0, use the target dependent heuristic.",
1097 0, 0, 0) 1153 0, 0, 0)
1098 1154
1099 DEFPARAM (PARAM_MAX_TAIL_MERGE_COMPARISONS, 1155 DEFPARAM (PARAM_MAX_TAIL_MERGE_COMPARISONS,
1100 "max-tail-merge-comparisons", 1156 "max-tail-merge-comparisons",
1101 "Maximum amount of similar bbs to compare a bb with.", 1157 "Maximum amount of similar bbs to compare a bb with.",
1137 "max-slsr-cand-scan", 1193 "max-slsr-cand-scan",
1138 "Maximum length of candidate scans for straight-line " 1194 "Maximum length of candidate scans for straight-line "
1139 "strength reduction.", 1195 "strength reduction.",
1140 50, 1, 999999) 1196 50, 1, 999999)
1141 1197
1198 /* ASan stands for AddressSanitizer: https://github.com/google/sanitizers. */
1199
1142 DEFPARAM (PARAM_ASAN_STACK, 1200 DEFPARAM (PARAM_ASAN_STACK,
1143 "asan-stack", 1201 "asan-stack",
1144 "Enable asan stack protection.", 1202 "Enable asan stack protection.",
1145 1, 0, 1) 1203 1, 0, 1)
1146 1204
1189 DEFPARAM (PARAM_UNINIT_CONTROL_DEP_ATTEMPTS, 1247 DEFPARAM (PARAM_UNINIT_CONTROL_DEP_ATTEMPTS,
1190 "uninit-control-dep-attempts", 1248 "uninit-control-dep-attempts",
1191 "Maximum number of nested calls to search for control dependencies " 1249 "Maximum number of nested calls to search for control dependencies "
1192 "during uninitialized variable analysis.", 1250 "during uninitialized variable analysis.",
1193 1000, 1, 0) 1251 1000, 1, 0)
1194
1195 DEFPARAM (PARAM_CHKP_MAX_CTOR_SIZE,
1196 "chkp-max-ctor-size",
1197 "Maximum number of statements to be included into a single static "
1198 "constructor generated by Pointer Bounds Checker.",
1199 5000, 100, 0)
1200 1252
1201 DEFPARAM (PARAM_FSM_SCALE_PATH_STMTS, 1253 DEFPARAM (PARAM_FSM_SCALE_PATH_STMTS,
1202 "fsm-scale-path-stmts", 1254 "fsm-scale-path-stmts",
1203 "Scale factor to apply to the number of statements in a threading path when comparing to the number of (scaled) blocks.", 1255 "Scale factor to apply to the number of statements in a threading path when comparing to the number of (scaled) blocks.",
1204 2, 1, 10) 1256 2, 1, 10)
1238 "Schedule type of omp schedule for loops parallelized by " 1290 "Schedule type of omp schedule for loops parallelized by "
1239 "parloops (static, dynamic, guided, auto, runtime).", 1291 "parloops (static, dynamic, guided, auto, runtime).",
1240 static, 1292 static,
1241 static, dynamic, guided, auto, runtime) 1293 static, dynamic, guided, auto, runtime)
1242 1294
1295 DEFPARAM (PARAM_PARLOOPS_MIN_PER_THREAD,
1296 "parloops-min-per-thread",
1297 "Minimum number of iterations per thread of an innermost "
1298 "parallelized loop.",
1299 100, 2, 0)
1300
1243 DEFPARAM (PARAM_MAX_SSA_NAME_QUERY_DEPTH, 1301 DEFPARAM (PARAM_MAX_SSA_NAME_QUERY_DEPTH,
1244 "max-ssa-name-query-depth", 1302 "max-ssa-name-query-depth",
1245 "Maximum recursion depth allowed when querying a property of an" 1303 "Maximum recursion depth allowed when querying a property of an"
1246 " SSA name.", 1304 " SSA name.",
1247 3, 1, 10) 1305 3, 1, 10)
1266 "is considered unpredictable.", 1324 "is considered unpredictable.",
1267 40, 0, 200) 1325 40, 0, 200)
1268 1326
1269 DEFPARAM (PARAM_HSA_GEN_DEBUG_STORES, 1327 DEFPARAM (PARAM_HSA_GEN_DEBUG_STORES,
1270 "hsa-gen-debug-stores", 1328 "hsa-gen-debug-stores",
1271 "Level of hsa debug stores verbosity", 1329 "Level of hsa debug stores verbosity.",
1272 0, 0, 1) 1330 0, 0, 1)
1273 1331
1274 DEFPARAM (PARAM_MAX_SPECULATIVE_DEVIRT_MAYDEFS, 1332 DEFPARAM (PARAM_MAX_SPECULATIVE_DEVIRT_MAYDEFS,
1275 "max-speculative-devirt-maydefs", 1333 "max-speculative-devirt-maydefs",
1276 "Maximum number of may-defs visited when devirtualizing " 1334 "Maximum number of may-defs visited when devirtualizing "
1277 "speculatively", 50, 0, 0) 1335 "speculatively.", 50, 0, 0)
1278 1336
1279 DEFPARAM (PARAM_MAX_VRP_SWITCH_ASSERTIONS, 1337 DEFPARAM (PARAM_MAX_VRP_SWITCH_ASSERTIONS,
1280 "max-vrp-switch-assertions", 1338 "max-vrp-switch-assertions",
1281 "Maximum number of assertions to add along the default " 1339 "Maximum number of assertions to add along the default "
1282 "edge of a switch statement during VRP", 1340 "edge of a switch statement during VRP.",
1283 10, 0, 0) 1341 10, 0, 0)
1284 1342
1285 DEFPARAM (PARAM_VECT_EPILOGUES_NOMASK, 1343 DEFPARAM (PARAM_VECT_EPILOGUES_NOMASK,
1286 "vect-epilogues-nomask", 1344 "vect-epilogues-nomask",
1287 "Enable loop epilogue vectorization using smaller vector size.", 1345 "Enable loop epilogue vectorization using smaller vector size.",
1288 0, 0, 1) 1346 0, 0, 1)
1289 1347
1348 DEFPARAM(PARAM_UNROLL_JAM_MIN_PERCENT,
1349 "unroll-jam-min-percent",
1350 "Minimum percentage of memrefs that must go away for unroll-and-jam to be considered profitable.",
1351 1, 0, 100)
1352
1353 DEFPARAM(PARAM_UNROLL_JAM_MAX_UNROLL,
1354 "unroll-jam-max-unroll",
1355 "Maximum unroll factor for the unroll-and-jam transformation.",
1356 4, 0, 0)
1357
1358 DEFPARAM(PARAM_AVOID_FMA_MAX_BITS,
1359 "avoid-fma-max-bits",
1360 "Maximum number of bits for which we avoid creating FMAs.",
1361 0, 0, 512)
1362
1290 /* 1363 /*
1291 1364
1292 Local variables: 1365 Local variables:
1293 mode:c 1366 mode:c
1294 End: 1367 End: