gcc/predict.def

   1 /* Definitions for the branch prediction routines in the GNU compiler.
   2    Copyright (C) 2001-2024 Free Software Foundation, Inc.
   3
   4 This file is part of GCC.
   5
   6 GCC is free software; you can redistribute it and/or modify it under
   7 the terms of the GNU General Public License as published by the Free
   8 Software Foundation; either version 3, or (at your option) any later
   9 version.
  10
  11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14 for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GCC; see the file COPYING3.  If not see
  18 <http://www.gnu.org/licenses/>.  */
  19
  20 /* Before including this file, you should define a macro:
  21
  22      DEF_PREDICTOR (ENUM, NAME, HITRATE)
  23
  24    This macro will be called once for each predictor.  The ENUM will
  25    be of type `enum br_predictor', and will enumerate all supported
  26    predictors.  The order of DEF_PREDICTOR calls is important, as
  27    in the first match combining heuristics, the predictor appearing
  28    first in this file will win.
  29
  30    NAME is used in the debugging output to determine predictor type.
  31
  32    HITRATE is the probability that edge predicted by predictor as taken
  33    will be really taken (so it should be always above
  34    REG_BR_PROB_BASE / 2).  */
  35
  36
  37 /* A value used as final outcome of all heuristics.  */
  38 DEF_PREDICTOR (PRED_COMBINED, "combined", PROB_ALWAYS, 0)
  39
  40 /* An outcome estimated by Dempster-Shaffer theory.  */
  41 DEF_PREDICTOR (PRED_DS_THEORY, "DS theory", PROB_ALWAYS, 0)
  42
  43 /* A combined heuristics using probability determined by first
  44    matching heuristics from this list.  */
  45 DEF_PREDICTOR (PRED_FIRST_MATCH, "first match", PROB_ALWAYS, 0)
  46
  47 /* Heuristic applying when no heuristic below applies.  */
  48 DEF_PREDICTOR (PRED_NO_PREDICTION, "no prediction", PROB_ALWAYS, 0)
  49
  50 /* Mark unconditional jump as taken.  */
  51 DEF_PREDICTOR (PRED_UNCONDITIONAL, "unconditional jump", PROB_ALWAYS,
  52                PRED_FLAG_FIRST_MATCH)
  53
  54 /* Use number of loop iterations determined by # of iterations
  55    analysis to set probability.  We don't want to use Dempster-Shaffer
  56    theory here, as the predictions is exact.  */
  57 DEF_PREDICTOR (PRED_LOOP_ITERATIONS, "loop iterations", PROB_UNINITIALIZED,
  58                PRED_FLAG_FIRST_MATCH)
  59
  60 /* Hints provided by user via __builtin_expect_with_probability.  */
  61 DEF_PREDICTOR (PRED_BUILTIN_EXPECT_WITH_PROBABILITY,
  62                "__builtin_expect_with_probability", PROB_UNINITIALIZED,
  63                PRED_FLAG_FIRST_MATCH)
  64
  65 /* Assume that any given atomic operation has low contention,
  66    and thus the compare-and-swap operation succeeds. */
  67 DEF_PREDICTOR (PRED_COMPARE_AND_SWAP, "compare and swap", PROB_VERY_LIKELY,
  68                PRED_FLAG_FIRST_MATCH)
  69
  70 /* Hints dropped by user via __builtin_expect feature.  Note: the
  71    probability of PROB_VERY_LIKELY is now overwritten by param
  72    builtin_expect_probability with a default value of HITRATE(90).
  73    Refer to param.def for details.  */
  74 DEF_PREDICTOR (PRED_BUILTIN_EXPECT, "__builtin_expect", PROB_VERY_LIKELY,
  75                PRED_FLAG_FIRST_MATCH)
  76
  77 /* Branches to hot labels are likely.  */
  78 DEF_PREDICTOR (PRED_HOT_LABEL, "hot label", HITRATE (90),
  79                PRED_FLAG_FIRST_MATCH)
  80
  81 /* Branches to cold labels are extremely unlikely.  */
  82 DEF_PREDICTOR (PRED_COLD_LABEL, "cold label", HITRATE (90),
  83                PRED_FLAG_FIRST_MATCH)
  84
  85 /* Return value of malloc function is almost always non-null.  */
  86 DEF_PREDICTOR (PRED_MALLOC_NONNULL, "malloc returned non-NULL", \
  87                PROB_VERY_LIKELY, PRED_FLAG_FIRST_MATCH)
  88
  89 /* Use number of loop iterations guessed by the contents of the loop.  */
  90 DEF_PREDICTOR (PRED_LOOP_ITERATIONS_GUESSED, "guessed loop iterations",
  91                PROB_UNINITIALIZED, PRED_FLAG_FIRST_MATCH)
  92
  93 /* Use number of loop iterations guessed by the contents of the loop.  */
  94 DEF_PREDICTOR (PRED_LOOP_ITERATIONS_MAX, "guessed loop iterations",
  95                PROB_UNINITIALIZED, PRED_FLAG_FIRST_MATCH)
  96
  97 /* Prediction which is an outcome of combining multiple value predictions.  */
  98 DEF_PREDICTOR (PRED_COMBINED_VALUE_PREDICTIONS,
  99                "combined value predictions", PROB_UNINITIALIZED, 0)
 100
 101 /* Prediction which is an outcome of combining multiple value predictions
 102    on PHI statement (this is less accurate since we do not know reverse
 103    edge probabilities at that time).  */
 104 DEF_PREDICTOR (PRED_COMBINED_VALUE_PREDICTIONS_PHI,
 105                "combined value predictions", PROB_UNINITIALIZED, 0)
 106
 107 /* Branch containing goto is probably not taken.  */
 108 DEF_PREDICTOR (PRED_CONTINUE, "continue", HITRATE (67), 0)
 109
 110 /* Branch to basic block containing call marked by noreturn attribute.  */
 111 DEF_PREDICTOR (PRED_NORETURN, "noreturn call", PROB_VERY_LIKELY,
 112                PRED_FLAG_FIRST_MATCH)
 113
 114 /* Branch to basic block containing call marked by cold function attribute.  */
 115 DEF_PREDICTOR (PRED_COLD_FUNCTION, "cold function call", PROB_VERY_LIKELY,
 116                PRED_FLAG_FIRST_MATCH)
 117
 118 /* Edge causing loop to terminate is probably not taken.  */
 119 DEF_PREDICTOR (PRED_LOOP_EXIT, "loop exit", HITRATE (89),
 120                PRED_FLAG_FIRST_MATCH)
 121
 122 /* Same as LOOP_EXIT but for loops containing recursive call.  */
 123 DEF_PREDICTOR (PRED_LOOP_EXIT_WITH_RECURSION, "loop exit with recursion",
 124                HITRATE (78), PRED_FLAG_FIRST_MATCH)
 125
 126 /* Edge causing loop to terminate by computing value used by later
 127    conditional.  */
 128 DEF_PREDICTOR (PRED_LOOP_EXTRA_EXIT, "extra loop exit", HITRATE (67),
 129                PRED_FLAG_FIRST_MATCH)
 130
 131 /* Pointers are usually not NULL.  */
 132 DEF_PREDICTOR (PRED_POINTER, "pointer", HITRATE (70), 0)
 133 DEF_PREDICTOR (PRED_TREE_POINTER, "pointer (on trees)", HITRATE (70), 0)
 134
 135 /* NE is probable, EQ not etc...  */
 136 DEF_PREDICTOR (PRED_OPCODE_POSITIVE, "opcode values positive", HITRATE (59), 0)
 137 DEF_PREDICTOR (PRED_OPCODE_NONEQUAL, "opcode values nonequal", HITRATE (66), 0)
 138 DEF_PREDICTOR (PRED_FPOPCODE, "fp_opcode", HITRATE (90), 0)
 139 DEF_PREDICTOR (PRED_TREE_OPCODE_POSITIVE, "opcode values positive (on trees)",
 140                HITRATE (59), 0)
 141 DEF_PREDICTOR (PRED_TREE_OPCODE_NONEQUAL, "opcode values nonequal (on trees)",
 142                HITRATE (66), 0)
 143 DEF_PREDICTOR (PRED_TREE_FPOPCODE, "fp_opcode (on trees)", HITRATE (90), 0)
 144
 145 /* Branch guarding call is probably taken.  */
 146 DEF_PREDICTOR (PRED_CALL, "call", HITRATE (67), 0)
 147
 148 /* Call predictors are for now ignored, lets leave the predictor
 149    to measure its benefit.  */
 150 DEF_PREDICTOR (PRED_INDIR_CALL, "indirect call", PROB_EVEN, 0)
 151 DEF_PREDICTOR (PRED_POLYMORPHIC_CALL, "polymorphic call", PROB_EVEN, 0)
 152 DEF_PREDICTOR (PRED_RECURSIVE_CALL, "recursive call", PROB_EVEN, 0)
 153
 154 /* Branch causing function to terminate is probably not taken.  */
 155 DEF_PREDICTOR (PRED_TREE_EARLY_RETURN, "early return (on trees)", HITRATE (66),
 156                0)
 157
 158 /* Branch containing goto is probably not taken.  */
 159 DEF_PREDICTOR (PRED_GOTO, "goto", HITRATE (66), 0)
 160
 161 /* Branch ending with return constant is probably not taken.  */
 162 DEF_PREDICTOR (PRED_CONST_RETURN, "const return", HITRATE (65), 0)
 163
 164 /* Branch ending with return negative constant is probably not taken.  */
 165 DEF_PREDICTOR (PRED_NEGATIVE_RETURN, "negative return", HITRATE (98), 0)
 166
 167 /* Branch ending with return; is probably not taken */
 168 DEF_PREDICTOR (PRED_NULL_RETURN, "null return", HITRATE (71), 0)
 169
 170 /* Branches to compare induction variable to a loop bound is
 171    extremely likely.  */
 172 DEF_PREDICTOR (PRED_LOOP_IV_COMPARE_GUESS, "guess loop iv compare",
 173                HITRATE (64), 0)
 174
 175 /* Use number of loop iterations determined by # of iterations analysis
 176    to set probability of branches that compares IV to loop bound variable.  */
 177 DEF_PREDICTOR (PRED_LOOP_IV_COMPARE, "loop iv compare", PROB_UNINITIALIZED,
 178                PRED_FLAG_FIRST_MATCH)
 179
 180 /* In the following code
 181    for (loop1)
 182      if (cond)
 183        for (loop2)
 184          body;
 185    guess that cond is unlikely.  */
 186 DEF_PREDICTOR (PRED_LOOP_GUARD, "loop guard", HITRATE (73), 0)
 187
 188 /* Same but for loops containing recursion.  */
 189 DEF_PREDICTOR (PRED_LOOP_GUARD_WITH_RECURSION, "loop guard with recursion",
 190                HITRATE (85), 0)
 191
 192 /* The following predictors are used in Fortran. */
 193
 194 /* Branch leading to an integer overflow are extremely unlikely.  */
 195 DEF_PREDICTOR (PRED_FORTRAN_OVERFLOW, "Fortran overflow", PROB_ALWAYS,
 196                PRED_FLAG_FIRST_MATCH)
 197
 198 /* Branch leading to a failure status are unlikely.  This can occur for out
 199    of memory.  This predictor only occurs when the user explicitly asked
 200    for a return status.  By default, the code aborts,
 201    which is handled via PRED_NORETURN.  */
 202 DEF_PREDICTOR (PRED_FORTRAN_FAIL_ALLOC, "Fortran fail alloc",
 203                PROB_VERY_LIKELY, 0)
 204
 205 /* Predictor is used for an allocation of an already allocated memory or
 206    deallocating an already deallocated allocatable.  */
 207 DEF_PREDICTOR (PRED_FORTRAN_REALLOC, "Fortran repeated allocation/deallocation",
 208                PROB_LIKELY, 0)
 209
 210 /* Branch leading to an I/O failure status are unlikely.  This predictor is
 211    used for I/O failures such as for invalid unit numbers.  This predictor
 212    only occurs when the user explicitly asked for a return status.  By default,
 213    the code aborts, which is handled via PRED_NORETURN.  */
 214 DEF_PREDICTOR (PRED_FORTRAN_FAIL_IO, "Fortran fail IO", HITRATE (85), 0)
 215
 216 /* Branch leading to a run-time warning message which is printed only once
 217    are unlikely.  The print-warning branch itself can be likely or unlikely.  */
 218 DEF_PREDICTOR (PRED_FORTRAN_WARN_ONCE, "Fortran warn once", HITRATE (75), 0)
 219
 220 /* Branch belonging to a zero-sized array.  */
 221 DEF_PREDICTOR (PRED_FORTRAN_SIZE_ZERO, "Fortran zero-sized array", \
 222                HITRATE (99), 0)
 223
 224 /* Branch belonging to an invalid bound index, in a context where it is
 225    standard conform and well defined but rather pointless and, hence, rather
 226    unlikely to occur.  */
 227 DEF_PREDICTOR (PRED_FORTRAN_INVALID_BOUND, "Fortran invalid bound", \
 228                HITRATE (90), 0)
 229
 230 /* Branch belonging to the handling of absent optional arguments.  This
 231    predictor is used when an optional dummy argument, associated with an
 232    absent argument, is passed on as actual argument to another procedure,
 233    which in turn has an optional argument.  */
 234 DEF_PREDICTOR (PRED_FORTRAN_ABSENT_DUMMY, "Fortran absent dummy", \
 235                HITRATE (60), 0)
 236
 237 /* Fortran DO statement generates a pre-header guard:
 238    empty = (step > 0 ? to < from : to > from), which can be predicted
 239    to be very likely.  */
 240 DEF_PREDICTOR (PRED_FORTRAN_LOOP_PREHEADER, "Fortran loop preheader", \
 241                HITRATE (99), 0)
 242
 243 /* Fortran assumed size arrays can be non-contiguous, so they need
 244    to be repacked.  */
 245
 246 DEF_PREDICTOR (PRED_FORTRAN_CONTIGUOUS, "Fortran contiguous", \
 247                HITRATE (75), 0)
 248