gcc/predict.c

   1 /* Branch prediction routines for the GNU compiler.
   2    Copyright (C) 2000, 2001, 2002 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 2, 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 COPYING.  If not, write to the Free
  18 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
  19 02111-1307, USA.  */
  20
  21 /* References:
  22
  23    [1] "Branch Prediction for Free"
  24        Ball and Larus; PLDI '93.
  25    [2] "Static Branch Frequency and Program Profile Analysis"
  26        Wu and Larus; MICRO-27.
  27    [3] "Corpus-based Static Branch Prediction"
  28        Calder, Grunwald, Lindsay, Martin, Mozer, and Zorn; PLDI '95.  */
  29
  30
  31 #include "config.h"
  32 #include "system.h"
  33 #include "coretypes.h"
  34 #include "tm.h"
  35 #include "tree.h"
  36 #include "rtl.h"
  37 #include "tm_p.h"
  38 #include "hard-reg-set.h"
  39 #include "basic-block.h"
  40 #include "insn-config.h"
  41 #include "regs.h"
  42 #include "flags.h"
  43 #include "output.h"
  44 #include "function.h"
  45 #include "except.h"
  46 #include "toplev.h"
  47 #include "recog.h"
  48 #include "expr.h"
  49 #include "predict.h"
  50 #include "profile.h"
  51 #include "real.h"
  52 #include "params.h"
  53 #include "target.h"
  54 #include "loop.h"
  55
  56 /* real constants: 0, 1, 1-1/REG_BR_PROB_BASE, REG_BR_PROB_BASE, 0.5,
  57                    REAL_BB_FREQ_MAX.  */
  58 static REAL_VALUE_TYPE real_zero, real_one, real_almost_one, real_br_prob_base,
  59                        real_one_half, real_bb_freq_max;
  60
  61 /* Random guesstimation given names.  */
  62 #define PROB_VERY_UNLIKELY      (REG_BR_PROB_BASE / 10 - 1)
  63 #define PROB_EVEN               (REG_BR_PROB_BASE / 2)
  64 #define PROB_VERY_LIKELY        (REG_BR_PROB_BASE - PROB_VERY_UNLIKELY)
  65 #define PROB_ALWAYS             (REG_BR_PROB_BASE)
  66
  67 static bool predicted_by_p               PARAMS ((basic_block,
  68                                                   enum br_predictor));
  69 static void combine_predictions_for_insn PARAMS ((rtx, basic_block));
  70 static void dump_prediction              PARAMS ((enum br_predictor, int,
  71                                                   basic_block, int));
  72 static void estimate_loops_at_level      PARAMS ((struct loop *loop));
  73 static void propagate_freq               PARAMS ((struct loop *));
  74 static void estimate_bb_frequencies      PARAMS ((struct loops *));
  75 static void counts_to_freqs              PARAMS ((void));
  76 static void process_note_predictions     PARAMS ((basic_block, int *,
  77                                                   dominance_info,
  78                                                   dominance_info));
  79 static void process_note_prediction      PARAMS ((basic_block, int *,
  80                                                   dominance_info,
  81                                                   dominance_info, int, int));
  82 static bool last_basic_block_p           PARAMS ((basic_block));
  83 static void compute_function_frequency   PARAMS ((void));
  84 static void choose_function_section      PARAMS ((void));
  85 static bool can_predict_insn_p           PARAMS ((rtx));
  86
  87 /* Information we hold about each branch predictor.
  88    Filled using information from predict.def.  */
  89
  90 struct predictor_info
  91 {
  92   const char *const name;       /* Name used in the debugging dumps.  */
  93   const int hitrate;            /* Expected hitrate used by
  94                                    predict_insn_def call.  */
  95   const int flags;
  96 };
  97
  98 /* Use given predictor without Dempster-Shaffer theory if it matches
  99    using first_match heuristics.  */
 100 #define PRED_FLAG_FIRST_MATCH 1
 101
 102 /* Recompute hitrate in percent to our representation.  */
 103
 104 #define HITRATE(VAL) ((int) ((VAL) * REG_BR_PROB_BASE + 50) / 100)
 105
 106 #define DEF_PREDICTOR(ENUM, NAME, HITRATE, FLAGS) {NAME, HITRATE, FLAGS},
 107 static const struct predictor_info predictor_info[]= {
 108 #include "predict.def"
 109
 110   /* Upper bound on predictors.  */
 111   {NULL, 0, 0}
 112 };
 113 #undef DEF_PREDICTOR
 114
 115 /* Return true in case BB can be CPU intensive and should be optimized
 116    for maximal perofmrance.  */
 117
 118 bool
 119 maybe_hot_bb_p (bb)
 120      basic_block bb;
 121 {
 122   if (profile_info.count_profiles_merged
 123       && flag_branch_probabilities
 124       && (bb->count
 125           < profile_info.max_counter_in_program
 126           / PARAM_VALUE (HOT_BB_COUNT_FRACTION)))
 127     return false;
 128   if (bb->frequency < BB_FREQ_MAX / PARAM_VALUE (HOT_BB_FREQUENCY_FRACTION))
 129     return false;
 130   return true;
 131 }
 132
 133 /* Return true in case BB is cold and should be optimized for size.  */
 134
 135 bool
 136 probably_cold_bb_p (bb)
 137      basic_block bb;
 138 {
 139   if (profile_info.count_profiles_merged
 140       && flag_branch_probabilities
 141       && (bb->count
 142           < profile_info.max_counter_in_program
 143           / PARAM_VALUE (HOT_BB_COUNT_FRACTION)))
 144     return true;
 145   if (bb->frequency < BB_FREQ_MAX / PARAM_VALUE (HOT_BB_FREQUENCY_FRACTION))
 146     return true;
 147   return false;
 148 }
 149
 150 /* Return true in case BB is probably never executed.  */
 151 bool
 152 probably_never_executed_bb_p (bb)
 153         basic_block bb;
 154 {
 155   if (profile_info.count_profiles_merged
 156       && flag_branch_probabilities)
 157     return ((bb->count + profile_info.count_profiles_merged / 2)
 158             / profile_info.count_profiles_merged) == 0;
 159   return false;
 160 }
 161
 162 /* Return true if the one of outgoing edges is already predicted by
 163    PREDICTOR.  */
 164
 165 static bool
 166 predicted_by_p (bb, predictor)
 167      basic_block bb;
 168      enum br_predictor predictor;
 169 {
 170   rtx note;
 171   if (!INSN_P (bb->end))
 172     return false;
 173   for (note = REG_NOTES (bb->end); note; note = XEXP (note, 1))
 174     if (REG_NOTE_KIND (note) == REG_BR_PRED
 175         && INTVAL (XEXP (XEXP (note, 0), 0)) == (int)predictor)
 176       return true;
 177   return false;
 178 }
 179
 180 void
 181 predict_insn (insn, predictor, probability)
 182      rtx insn;
 183      int probability;
 184      enum br_predictor predictor;
 185 {
 186   if (!any_condjump_p (insn))
 187     abort ();
 188
 189   REG_NOTES (insn)
 190     = gen_rtx_EXPR_LIST (REG_BR_PRED,
 191                          gen_rtx_CONCAT (VOIDmode,
 192                                          GEN_INT ((int) predictor),
 193                                          GEN_INT ((int) probability)),
 194                          REG_NOTES (insn));
 195 }
 196
 197 /* Predict insn by given predictor.  */
 198
 199 void
 200 predict_insn_def (insn, predictor, taken)
 201      rtx insn;
 202      enum br_predictor predictor;
 203      enum prediction taken;
 204 {
 205    int probability = predictor_info[(int) predictor].hitrate;
 206
 207    if (taken != TAKEN)
 208      probability = REG_BR_PROB_BASE - probability;
 209
 210    predict_insn (insn, predictor, probability);
 211 }
 212
 213 /* Predict edge E with given probability if possible.  */
 214
 215 void
 216 predict_edge (e, predictor, probability)
 217      edge e;
 218      int probability;
 219      enum br_predictor predictor;
 220 {
 221   rtx last_insn;
 222   last_insn = e->src->end;
 223
 224   /* We can store the branch prediction information only about
 225      conditional jumps.  */
 226   if (!any_condjump_p (last_insn))
 227     return;
 228
 229   /* We always store probability of branching.  */
 230   if (e->flags & EDGE_FALLTHRU)
 231     probability = REG_BR_PROB_BASE - probability;
 232
 233   predict_insn (last_insn, predictor, probability);
 234 }
 235
 236 /* Return true when we can store prediction on insn INSN.
 237    At the moment we represent predictions only on conditional
 238    jumps, not at computed jump or other complicated cases.  */
 239 static bool
 240 can_predict_insn_p (insn)
 241         rtx insn;
 242 {
 243   return (GET_CODE (insn) == JUMP_INSN
 244           && any_condjump_p (insn)
 245           && BLOCK_FOR_INSN (insn)->succ->succ_next);
 246 }
 247
 248 /* Predict edge E by given predictor if possible.  */
 249
 250 void
 251 predict_edge_def (e, predictor, taken)
 252      edge e;
 253      enum br_predictor predictor;
 254      enum prediction taken;
 255 {
 256    int probability = predictor_info[(int) predictor].hitrate;
 257
 258    if (taken != TAKEN)
 259      probability = REG_BR_PROB_BASE - probability;
 260
 261    predict_edge (e, predictor, probability);
 262 }
 263
 264 /* Invert all branch predictions or probability notes in the INSN.  This needs
 265    to be done each time we invert the condition used by the jump.  */
 266
 267 void
 268 invert_br_probabilities (insn)
 269      rtx insn;
 270 {
 271   rtx note;
 272
 273   for (note = REG_NOTES (insn); note; note = XEXP (note, 1))
 274     if (REG_NOTE_KIND (note) == REG_BR_PROB)
 275       XEXP (note, 0) = GEN_INT (REG_BR_PROB_BASE - INTVAL (XEXP (note, 0)));
 276     else if (REG_NOTE_KIND (note) == REG_BR_PRED)
 277       XEXP (XEXP (note, 0), 1)
 278         = GEN_INT (REG_BR_PROB_BASE - INTVAL (XEXP (XEXP (note, 0), 1)));
 279 }
 280
 281 /* Dump information about the branch prediction to the output file.  */
 282
 283 static void
 284 dump_prediction (predictor, probability, bb, used)
 285      enum br_predictor predictor;
 286      int probability;
 287      basic_block bb;
 288      int used;
 289 {
 290   edge e = bb->succ;
 291
 292   if (!rtl_dump_file)
 293     return;
 294
 295   while (e && (e->flags & EDGE_FALLTHRU))
 296     e = e->succ_next;
 297
 298   fprintf (rtl_dump_file, "  %s heuristics%s: %.1f%%",
 299            predictor_info[predictor].name,
 300            used ? "" : " (ignored)", probability * 100.0 / REG_BR_PROB_BASE);
 301
 302   if (bb->count)
 303     {
 304       fprintf (rtl_dump_file, "  exec ");
 305       fprintf (rtl_dump_file, HOST_WIDEST_INT_PRINT_DEC, bb->count);
 306       if (e)
 307         {
 308           fprintf (rtl_dump_file, " hit ");
 309           fprintf (rtl_dump_file, HOST_WIDEST_INT_PRINT_DEC, e->count);
 310           fprintf (rtl_dump_file, " (%.1f%%)", e->count * 100.0 / bb->count);
 311         }
 312     }
 313
 314   fprintf (rtl_dump_file, "\n");
 315 }
 316
 317 /* Combine all REG_BR_PRED notes into single probability and attach REG_BR_PROB
 318    note if not already present.  Remove now useless REG_BR_PRED notes.  */
 319
 320 static void
 321 combine_predictions_for_insn (insn, bb)
 322      rtx insn;
 323      basic_block bb;
 324 {
 325   rtx prob_note = find_reg_note (insn, REG_BR_PROB, 0);
 326   rtx *pnote = &REG_NOTES (insn);
 327   rtx note;
 328   int best_probability = PROB_EVEN;
 329   int best_predictor = END_PREDICTORS;
 330   int combined_probability = REG_BR_PROB_BASE / 2;
 331   int d;
 332   bool first_match = false;
 333   bool found = false;
 334
 335   if (rtl_dump_file)
 336     fprintf (rtl_dump_file, "Predictions for insn %i bb %i\n", INSN_UID (insn),
 337              bb->index);
 338
 339   /* We implement "first match" heuristics and use probability guessed
 340      by predictor with smallest index.  In the future we will use better
 341      probability combination techniques.  */
 342   for (note = REG_NOTES (insn); note; note = XEXP (note, 1))
 343     if (REG_NOTE_KIND (note) == REG_BR_PRED)
 344       {
 345         int predictor = INTVAL (XEXP (XEXP (note, 0), 0));
 346         int probability = INTVAL (XEXP (XEXP (note, 0), 1));
 347
 348         found = true;
 349         if (best_predictor > predictor)
 350           best_probability = probability, best_predictor = predictor;
 351
 352         d = (combined_probability * probability
 353              + (REG_BR_PROB_BASE - combined_probability)
 354              * (REG_BR_PROB_BASE - probability));
 355
 356         /* Use FP math to avoid overflows of 32bit integers.  */
 357         if (d == 0)
 358           /* If one probability is 0% and one 100%, avoid division by zero.  */
 359           combined_probability = REG_BR_PROB_BASE / 2;
 360         else
 361           combined_probability = (((double) combined_probability) * probability
 362                                   * REG_BR_PROB_BASE / d + 0.5);
 363       }
 364
 365   /* Decide which heuristic to use.  In case we didn't match anything,
 366      use no_prediction heuristic, in case we did match, use either
 367      first match or Dempster-Shaffer theory depending on the flags.  */
 368
 369   if (predictor_info [best_predictor].flags & PRED_FLAG_FIRST_MATCH)
 370     first_match = true;
 371
 372   if (!found)
 373     dump_prediction (PRED_NO_PREDICTION, combined_probability, bb, true);
 374   else
 375     {
 376       dump_prediction (PRED_DS_THEORY, combined_probability, bb, !first_match);
 377       dump_prediction (PRED_FIRST_MATCH, best_probability, bb, first_match);
 378     }
 379
 380   if (first_match)
 381     combined_probability = best_probability;
 382   dump_prediction (PRED_COMBINED, combined_probability, bb, true);
 383
 384   while (*pnote)
 385     {
 386       if (REG_NOTE_KIND (*pnote) == REG_BR_PRED)
 387         {
 388           int predictor = INTVAL (XEXP (XEXP (*pnote, 0), 0));
 389           int probability = INTVAL (XEXP (XEXP (*pnote, 0), 1));
 390
 391           dump_prediction (predictor, probability, bb,
 392                            !first_match || best_predictor == predictor);
 393           *pnote = XEXP (*pnote, 1);
 394         }
 395       else
 396         pnote = &XEXP (*pnote, 1);
 397     }
 398
 399   if (!prob_note)
 400     {
 401       REG_NOTES (insn)
 402         = gen_rtx_EXPR_LIST (REG_BR_PROB,
 403                              GEN_INT (combined_probability), REG_NOTES (insn));
 404
 405       /* Save the prediction into CFG in case we are seeing non-degenerated
 406          conditional jump.  */
 407       if (bb->succ->succ_next)
 408         {
 409           BRANCH_EDGE (bb)->probability = combined_probability;
 410           FALLTHRU_EDGE (bb)->probability
 411             = REG_BR_PROB_BASE - combined_probability;
 412         }
 413     }
 414 }
 415
 416 /* Statically estimate the probability that a branch will be taken.
 417    ??? In the next revision there will be a number of other predictors added
 418    from the above references. Further, each heuristic will be factored out
 419    into its own function for clarity (and to facilitate the combination of
 420    predictions).  */
 421
 422 void
 423 estimate_probability (loops_info)
 424      struct loops *loops_info;
 425 {
 426   dominance_info dominators, post_dominators;
 427   basic_block bb;
 428   int i;
 429
 430   connect_infinite_loops_to_exit ();
 431   dominators = calculate_dominance_info (CDI_DOMINATORS);
 432   post_dominators = calculate_dominance_info (CDI_POST_DOMINATORS);
 433
 434   /* Try to predict out blocks in a loop that are not part of a
 435      natural loop.  */
 436   for (i = 1; i < loops_info->num; i++)
 437     {
 438       basic_block bb, *bbs;
 439       int j;
 440       int exits;
 441       struct loop *loop = loops_info->parray[i];
 442
 443       flow_loop_scan (loops_info, loop, LOOP_EXIT_EDGES);
 444       exits = loop->num_exits;
 445
 446       bbs = get_loop_body (loop);
 447       for (j = 0; j < loop->num_nodes; j++)
 448         {
 449           int header_found = 0;
 450           edge e;
 451
 452           bb = bbs[j];
 453
 454           /* Bypass loop heuristics on continue statement.  These
 455              statements construct loops via "non-loop" constructs
 456              in the source language and are better to be handled
 457              separately.  */
 458           if (!can_predict_insn_p (bb->end)
 459               || predicted_by_p (bb, PRED_CONTINUE))
 460             continue;
 461
 462           /* Loop branch heuristics - predict an edge back to a
 463              loop's head as taken.  */
 464           for (e = bb->succ; e; e = e->succ_next)
 465             if (e->dest == loop->header
 466                 && e->src == loop->latch)
 467               {
 468                 header_found = 1;
 469                 predict_edge_def (e, PRED_LOOP_BRANCH, TAKEN);
 470               }
 471
 472           /* Loop exit heuristics - predict an edge exiting the loop if the
 473              conditinal has no loop header successors as not taken.  */
 474           if (!header_found)
 475             for (e = bb->succ; e; e = e->succ_next)
 476               if (e->dest->index < 0
 477                   || !flow_bb_inside_loop_p (loop, e->dest))
 478                 predict_edge
 479                   (e, PRED_LOOP_EXIT,
 480                    (REG_BR_PROB_BASE
 481                     - predictor_info [(int) PRED_LOOP_EXIT].hitrate)
 482                    / exits);
 483         }
 484     }
 485
 486   /* Attempt to predict conditional jumps using a number of heuristics.  */
 487   FOR_EACH_BB (bb)
 488     {
 489       rtx last_insn = bb->end;
 490       rtx cond, earliest;
 491       edge e;
 492
 493       if (! can_predict_insn_p (last_insn))
 494         continue;
 495
 496       for (e = bb->succ; e; e = e->succ_next)
 497         {
 498           /* Predict early returns to be probable, as we've already taken
 499              care for error returns and other are often used for fast paths
 500              trought function.  */
 501           if ((e->dest == EXIT_BLOCK_PTR
 502                || (e->dest->succ && !e->dest->succ->succ_next
 503                    && e->dest->succ->dest == EXIT_BLOCK_PTR))
 504                && !predicted_by_p (bb, PRED_NULL_RETURN)
 505                && !predicted_by_p (bb, PRED_CONST_RETURN)
 506                && !predicted_by_p (bb, PRED_NEGATIVE_RETURN)
 507                && !last_basic_block_p (e->dest))
 508             predict_edge_def (e, PRED_EARLY_RETURN, TAKEN);
 509
 510           /* Look for block we are guarding (ie we dominate it,
 511              but it doesn't postdominate us).  */
 512           if (e->dest != EXIT_BLOCK_PTR && e->dest != bb
 513               && dominated_by_p (dominators, e->dest, e->src)
 514               && !dominated_by_p (post_dominators, e->src, e->dest))
 515             {
 516               rtx insn;
 517
 518               /* The call heuristic claims that a guarded function call
 519                  is improbable.  This is because such calls are often used
 520                  to signal exceptional situations such as printing error
 521                  messages.  */
 522               for (insn = e->dest->head; insn != NEXT_INSN (e->dest->end);
 523                    insn = NEXT_INSN (insn))
 524                 if (GET_CODE (insn) == CALL_INSN
 525                     /* Constant and pure calls are hardly used to signalize
 526                        something exceptional.  */
 527                     && ! CONST_OR_PURE_CALL_P (insn))
 528                   {
 529                     predict_edge_def (e, PRED_CALL, NOT_TAKEN);
 530                     break;
 531                   }
 532             }
 533         }
 534
 535       cond = get_condition (last_insn, &earliest);
 536       if (! cond)
 537         continue;
 538
 539       /* Try "pointer heuristic."
 540          A comparison ptr == 0 is predicted as false.
 541          Similarly, a comparison ptr1 == ptr2 is predicted as false.  */
 542       if (GET_RTX_CLASS (GET_CODE (cond)) == '<'
 543           && ((REG_P (XEXP (cond, 0)) && REG_POINTER (XEXP (cond, 0)))
 544               || (REG_P (XEXP (cond, 1)) && REG_POINTER (XEXP (cond, 1)))))
 545         {
 546           if (GET_CODE (cond) == EQ)
 547             predict_insn_def (last_insn, PRED_POINTER, NOT_TAKEN);
 548           else if (GET_CODE (cond) == NE)
 549             predict_insn_def (last_insn, PRED_POINTER, TAKEN);
 550         }
 551       else
 552
 553       /* Try "opcode heuristic."
 554          EQ tests are usually false and NE tests are usually true. Also,
 555          most quantities are positive, so we can make the appropriate guesses
 556          about signed comparisons against zero.  */
 557         switch (GET_CODE (cond))
 558           {
 559           case CONST_INT:
 560             /* Unconditional branch.  */
 561             predict_insn_def (last_insn, PRED_UNCONDITIONAL,
 562                               cond == const0_rtx ? NOT_TAKEN : TAKEN);
 563             break;
 564
 565           case EQ:
 566           case UNEQ:
 567             /* Floating point comparisons appears to behave in a very
 568                inpredictable way because of special role of = tests in
 569                FP code.  */
 570             if (FLOAT_MODE_P (GET_MODE (XEXP (cond, 0))))
 571               ;
 572             /* Comparisons with 0 are often used for booleans and there is
 573                nothing usefull to predict about them.  */
 574             else if (XEXP (cond, 1) == const0_rtx
 575                      || XEXP (cond, 0) == const0_rtx)
 576               ;
 577             else
 578               predict_insn_def (last_insn, PRED_OPCODE_NONEQUAL, NOT_TAKEN);
 579             break;
 580
 581           case NE:
 582           case LTGT:
 583             /* Floating point comparisons appears to behave in a very
 584                inpredictable way because of special role of = tests in
 585                FP code.  */
 586             if (FLOAT_MODE_P (GET_MODE (XEXP (cond, 0))))
 587               ;
 588             /* Comparisons with 0 are often used for booleans and there is
 589                nothing usefull to predict about them.  */
 590             else if (XEXP (cond, 1) == const0_rtx
 591                      || XEXP (cond, 0) == const0_rtx)
 592               ;
 593             else
 594               predict_insn_def (last_insn, PRED_OPCODE_NONEQUAL, TAKEN);
 595             break;
 596
 597           case ORDERED:
 598             predict_insn_def (last_insn, PRED_FPOPCODE, TAKEN);
 599             break;
 600
 601           case UNORDERED:
 602             predict_insn_def (last_insn, PRED_FPOPCODE, NOT_TAKEN);
 603             break;
 604
 605           case LE:
 606           case LT:
 607             if (XEXP (cond, 1) == const0_rtx || XEXP (cond, 1) == const1_rtx
 608                 || XEXP (cond, 1) == constm1_rtx)
 609               predict_insn_def (last_insn, PRED_OPCODE_POSITIVE, NOT_TAKEN);
 610             break;
 611
 612           case GE:
 613           case GT:
 614             if (XEXP (cond, 1) == const0_rtx || XEXP (cond, 1) == const1_rtx
 615                 || XEXP (cond, 1) == constm1_rtx)
 616               predict_insn_def (last_insn, PRED_OPCODE_POSITIVE, TAKEN);
 617             break;
 618
 619           default:
 620             break;
 621           }
 622     }
 623
 624   /* Attach the combined probability to each conditional jump.  */
 625   FOR_EACH_BB (bb)
 626     if (GET_CODE (bb->end) == JUMP_INSN
 627         && any_condjump_p (bb->end)
 628         && bb->succ->succ_next != NULL)
 629       combine_predictions_for_insn (bb->end, bb);
 630
 631   free_dominance_info (post_dominators);
 632   free_dominance_info (dominators);
 633
 634   remove_fake_edges ();
 635   estimate_bb_frequencies (loops_info);
 636 }
 637 \f
 638 /* __builtin_expect dropped tokens into the insn stream describing expected
 639    values of registers.  Generate branch probabilities based off these
 640    values.  */
 641
 642 void
 643 expected_value_to_br_prob ()
 644 {
 645   rtx insn, cond, ev = NULL_RTX, ev_reg = NULL_RTX;
 646
 647   for (insn = get_insns (); insn ; insn = NEXT_INSN (insn))
 648     {
 649       switch (GET_CODE (insn))
 650         {
 651         case NOTE:
 652           /* Look for expected value notes.  */
 653           if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_EXPECTED_VALUE)
 654             {
 655               ev = NOTE_EXPECTED_VALUE (insn);
 656               ev_reg = XEXP (ev, 0);
 657               delete_insn (insn);
 658             }
 659           continue;
 660
 661         case CODE_LABEL:
 662           /* Never propagate across labels.  */
 663           ev = NULL_RTX;
 664           continue;
 665
 666         case JUMP_INSN:
 667           /* Look for simple conditional branches.  If we haven't got an
 668              expected value yet, no point going further.  */
 669           if (GET_CODE (insn) != JUMP_INSN || ev == NULL_RTX
 670               || ! any_condjump_p (insn))
 671             continue;
 672           break;
 673
 674         default:
 675           /* Look for insns that clobber the EV register.  */
 676           if (ev && reg_set_p (ev_reg, insn))
 677             ev = NULL_RTX;
 678           continue;
 679         }
 680
 681       /* Collect the branch condition, hopefully relative to EV_REG.  */
 682       /* ???  At present we'll miss things like
 683                 (expected_value (eq r70 0))
 684                 (set r71 -1)
 685                 (set r80 (lt r70 r71))
 686                 (set pc (if_then_else (ne r80 0) ...))
 687          as canonicalize_condition will render this to us as
 688                 (lt r70, r71)
 689          Could use cselib to try and reduce this further.  */
 690       cond = XEXP (SET_SRC (pc_set (insn)), 0);
 691       cond = canonicalize_condition (insn, cond, 0, NULL, ev_reg);
 692       if (! cond || XEXP (cond, 0) != ev_reg
 693           || GET_CODE (XEXP (cond, 1)) != CONST_INT)
 694         continue;
 695
 696       /* Substitute and simplify.  Given that the expression we're
 697          building involves two constants, we should wind up with either
 698          true or false.  */
 699       cond = gen_rtx_fmt_ee (GET_CODE (cond), VOIDmode,
 700                              XEXP (ev, 1), XEXP (cond, 1));
 701       cond = simplify_rtx (cond);
 702
 703       /* Turn the condition into a scaled branch probability.  */
 704       if (cond != const_true_rtx && cond != const0_rtx)
 705         abort ();
 706       predict_insn_def (insn, PRED_BUILTIN_EXPECT,
 707                         cond == const_true_rtx ? TAKEN : NOT_TAKEN);
 708     }
 709 }
 710 \f
 711 /* Check whether this is the last basic block of function.  Commonly tehre
 712    is one extra common cleanup block.  */
 713 static bool
 714 last_basic_block_p (bb)
 715      basic_block bb;
 716 {
 717   if (bb == EXIT_BLOCK_PTR)
 718     return false;
 719
 720   return (bb->next_bb == EXIT_BLOCK_PTR
 721           || (bb->next_bb->next_bb == EXIT_BLOCK_PTR
 722               && bb->succ && !bb->succ->succ_next
 723               && bb->succ->dest->next_bb == EXIT_BLOCK_PTR));
 724 }
 725
 726 /* Sets branch probabilities according to PREDiction and FLAGS. HEADS[bb->index]
 727    should be index of basic block in that we need to alter branch predictions
 728    (i.e. the first of our dominators such that we do not post-dominate it)
 729    (but we fill this information on demand, so -1 may be there in case this
 730    was not needed yet).  */
 731
 732 static void
 733 process_note_prediction (bb, heads, dominators, post_dominators, pred, flags)
 734      basic_block bb;
 735      int *heads;
 736      dominance_info dominators;
 737      dominance_info post_dominators;
 738      int pred;
 739      int flags;
 740 {
 741   edge e;
 742   int y;
 743   bool taken;
 744
 745   taken = flags & IS_TAKEN;
 746
 747   if (heads[bb->index] < 0)
 748     {
 749       /* This is first time we need this field in heads array; so
 750          find first dominator that we do not post-dominate (we are
 751          using already known members of heads array).  */
 752       basic_block ai = bb;
 753       basic_block next_ai = get_immediate_dominator (dominators, bb);
 754       int head;
 755
 756       while (heads[next_ai->index] < 0)
 757         {
 758           if (!dominated_by_p (post_dominators, next_ai, bb))
 759             break;
 760           heads[next_ai->index] = ai->index;
 761           ai = next_ai;
 762           next_ai = get_immediate_dominator (dominators, next_ai);
 763         }
 764       if (!dominated_by_p (post_dominators, next_ai, bb))
 765         head = next_ai->index;
 766       else
 767         head = heads[next_ai->index];
 768       while (next_ai != bb)
 769         {
 770           next_ai = ai;
 771           if (heads[ai->index] == ENTRY_BLOCK)
 772             ai = ENTRY_BLOCK_PTR;
 773           else
 774             ai = BASIC_BLOCK (heads[ai->index]);
 775           heads[next_ai->index] = head;
 776         }
 777     }
 778   y = heads[bb->index];
 779
 780   /* Now find the edge that leads to our branch and aply the prediction.  */
 781
 782   if (y == last_basic_block || !can_predict_insn_p (BASIC_BLOCK (y)->end))
 783     return;
 784   for (e = BASIC_BLOCK (y)->succ; e; e = e->succ_next)
 785     if (e->dest->index >= 0
 786         && dominated_by_p (post_dominators, e->dest, bb))
 787       predict_edge_def (e, pred, taken);
 788 }
 789
 790 /* Gathers NOTE_INSN_PREDICTIONs in given basic block and turns them
 791    into branch probabilities.  For description of heads array, see
 792    process_note_prediction.  */
 793
 794 static void
 795 process_note_predictions (bb, heads, dominators, post_dominators)
 796      basic_block bb;
 797      int *heads;
 798      dominance_info dominators;
 799      dominance_info post_dominators;
 800 {
 801   rtx insn;
 802   edge e;
 803
 804   /* Additionaly, we check here for blocks with no successors.  */
 805   int contained_noreturn_call = 0;
 806   int was_bb_head = 0;
 807   int noreturn_block = 1;
 808
 809   for (insn = bb->end; insn;
 810        was_bb_head |= (insn == bb->head), insn = PREV_INSN (insn))
 811     {
 812       if (GET_CODE (insn) != NOTE)
 813         {
 814           if (was_bb_head)
 815             break;
 816           else
 817             {
 818               /* Noreturn calls cause program to exit, therefore they are
 819                  always predicted as not taken.  */
 820               if (GET_CODE (insn) == CALL_INSN
 821                   && find_reg_note (insn, REG_NORETURN, NULL))
 822                 contained_noreturn_call = 1;
 823               continue;
 824             }
 825         }
 826       if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_PREDICTION)
 827         {
 828           int alg = (int) NOTE_PREDICTION_ALG (insn);
 829           /* Process single prediction note.  */
 830           process_note_prediction (bb,
 831                                    heads,
 832                                    dominators,
 833                                    post_dominators,
 834                                    alg, (int) NOTE_PREDICTION_FLAGS (insn));
 835           delete_insn (insn);
 836         }
 837     }
 838   for (e = bb->succ; e; e = e->succ_next)
 839     if (!(e->flags & EDGE_FAKE))
 840       noreturn_block = 0;
 841   if (contained_noreturn_call)
 842     {
 843       /* This block ended from other reasons than because of return.
 844          If it is because of noreturn call, this should certainly not
 845          be taken.  Otherwise it is probably some error recovery.  */
 846       process_note_prediction (bb,
 847                                heads,
 848                                dominators,
 849                                post_dominators, PRED_NORETURN, NOT_TAKEN);
 850     }
 851 }
 852
 853 /* Gathers NOTE_INSN_PREDICTIONs and turns them into
 854    branch probabilities.  */
 855
 856 void
 857 note_prediction_to_br_prob ()
 858 {
 859   basic_block bb;
 860   dominance_info post_dominators, dominators;
 861   int *heads;
 862
 863   /* To enable handling of noreturn blocks.  */
 864   add_noreturn_fake_exit_edges ();
 865   connect_infinite_loops_to_exit ();
 866
 867   post_dominators = calculate_dominance_info (CDI_POST_DOMINATORS);
 868   dominators = calculate_dominance_info (CDI_DOMINATORS);
 869
 870   heads = xmalloc (sizeof (int) * last_basic_block);
 871   memset (heads, -1, sizeof (int) * last_basic_block);
 872   heads[ENTRY_BLOCK_PTR->next_bb->index] = last_basic_block;
 873
 874   /* Process all prediction notes.  */
 875
 876   FOR_EACH_BB (bb)
 877     process_note_predictions (bb, heads, dominators, post_dominators);
 878
 879   free_dominance_info (post_dominators);
 880   free_dominance_info (dominators);
 881   free (heads);
 882
 883   remove_fake_edges ();
 884 }
 885 \f
 886 /* This is used to carry information about basic blocks.  It is
 887    attached to the AUX field of the standard CFG block.  */
 888
 889 typedef struct block_info_def
 890 {
 891   /* Estimated frequency of execution of basic_block.  */
 892   REAL_VALUE_TYPE frequency;
 893
 894   /* To keep queue of basic blocks to process.  */
 895   basic_block next;
 896
 897   /* True if block needs to be visited in prop_freqency.  */
 898   int tovisit:1;
 899
 900   /* Number of predecessors we need to visit first.  */
 901   int npredecessors;
 902 } *block_info;
 903
 904 /* Similar information for edges.  */
 905 typedef struct edge_info_def
 906 {
 907   /* In case edge is an loopback edge, the probability edge will be reached
 908      in case header is.  Estimated number of iterations of the loop can be
 909      then computed as 1 / (1 - back_edge_prob).  */
 910   REAL_VALUE_TYPE back_edge_prob;
 911   /* True if the edge is an loopback edge in the natural loop.  */
 912   int back_edge:1;
 913 } *edge_info;
 914
 915 #define BLOCK_INFO(B)   ((block_info) (B)->aux)
 916 #define EDGE_INFO(E)    ((edge_info) (E)->aux)
 917
 918 /* Helper function for estimate_bb_frequencies.
 919    Propagate the frequencies for LOOP.  */
 920
 921 static void
 922 propagate_freq (loop)
 923      struct loop *loop;
 924 {
 925   basic_block head = loop->header;
 926   basic_block bb;
 927   basic_block last;
 928   edge e;
 929   basic_block nextbb;
 930
 931   /* For each basic block we need to visit count number of his predecessors
 932      we need to visit first.  */
 933   FOR_EACH_BB (bb)
 934     {
 935       if (BLOCK_INFO (bb)->tovisit)
 936         {
 937           int count = 0;
 938
 939           for (e = bb->pred; e; e = e->pred_next)
 940             if (BLOCK_INFO (e->src)->tovisit && !(e->flags & EDGE_DFS_BACK))
 941               count++;
 942             else if (BLOCK_INFO (e->src)->tovisit
 943                      && rtl_dump_file && !EDGE_INFO (e)->back_edge)
 944               fprintf (rtl_dump_file,
 945                        "Irreducible region hit, ignoring edge to %i->%i\n",
 946                        e->src->index, bb->index);
 947           BLOCK_INFO (bb)->npredecessors = count;
 948         }
 949     }
 950
 951   memcpy (&BLOCK_INFO (head)->frequency, &real_one, sizeof (real_one));
 952   last = head;
 953   for (bb = head; bb; bb = nextbb)
 954     {
 955       REAL_VALUE_TYPE cyclic_probability, frequency;
 956
 957       memcpy (&cyclic_probability, &real_zero, sizeof (real_zero));
 958       memcpy (&frequency, &real_zero, sizeof (real_zero));
 959
 960       nextbb = BLOCK_INFO (bb)->next;
 961       BLOCK_INFO (bb)->next = NULL;
 962
 963       /* Compute frequency of basic block.  */
 964       if (bb != head)
 965         {
 966 #ifdef ENABLE_CHECKING
 967           for (e = bb->pred; e; e = e->pred_next)
 968             if (BLOCK_INFO (e->src)->tovisit && !(e->flags & EDGE_DFS_BACK))
 969               abort ();
 970 #endif
 971
 972           for (e = bb->pred; e; e = e->pred_next)
 973             if (EDGE_INFO (e)->back_edge)
 974               {
 975                 REAL_ARITHMETIC (cyclic_probability, PLUS_EXPR,
 976                                  cyclic_probability,
 977                                  EDGE_INFO (e)->back_edge_prob);
 978               }
 979             else if (!(e->flags & EDGE_DFS_BACK))
 980               {
 981                 REAL_VALUE_TYPE tmp;
 982
 983                 /*  frequency += (e->probability
 984                                   * BLOCK_INFO (e->src)->frequency /
 985                                   REG_BR_PROB_BASE);  */
 986
 987                 REAL_VALUE_FROM_INT (tmp, e->probability, 0,
 988                                      TYPE_MODE (double_type_node));
 989                 REAL_ARITHMETIC (tmp, MULT_EXPR, tmp,
 990                                  BLOCK_INFO (e->src)->frequency);
 991                 REAL_ARITHMETIC (tmp, RDIV_EXPR, tmp, real_br_prob_base);
 992                 REAL_ARITHMETIC (frequency, PLUS_EXPR, frequency, tmp);
 993               }
 994
 995           if (REAL_VALUES_LESS (real_almost_one, cyclic_probability))
 996             memcpy (&cyclic_probability, &real_almost_one, sizeof (real_zero));
 997
 998           /* BLOCK_INFO (bb)->frequency = frequency / (1 - cyclic_probability)
 999            */
1000
1001           REAL_ARITHMETIC (cyclic_probability, MINUS_EXPR, real_one,
1002                            cyclic_probability);
1003           REAL_ARITHMETIC (BLOCK_INFO (bb)->frequency,
1004                            RDIV_EXPR, frequency, cyclic_probability);
1005         }
1006
1007       BLOCK_INFO (bb)->tovisit = 0;
1008
1009       /* Compute back edge frequencies.  */
1010       for (e = bb->succ; e; e = e->succ_next)
1011         if (e->dest == head)
1012           {
1013             REAL_VALUE_TYPE tmp;
1014
1015             /* EDGE_INFO (e)->back_edge_prob
1016                   = ((e->probability * BLOCK_INFO (bb)->frequency)
1017                      / REG_BR_PROB_BASE); */
1018             REAL_VALUE_FROM_INT (tmp, e->probability, 0,
1019                                  TYPE_MODE (double_type_node));
1020             REAL_ARITHMETIC (tmp, MULT_EXPR, tmp,
1021                              BLOCK_INFO (bb)->frequency);
1022             REAL_ARITHMETIC (EDGE_INFO (e)->back_edge_prob,
1023                              RDIV_EXPR, tmp, real_br_prob_base);
1024
1025           }
1026
1027       /* Propagate to successor blocks.  */
1028       for (e = bb->succ; e; e = e->succ_next)
1029         if (!(e->flags & EDGE_DFS_BACK)
1030             && BLOCK_INFO (e->dest)->npredecessors)
1031           {
1032             BLOCK_INFO (e->dest)->npredecessors--;
1033             if (!BLOCK_INFO (e->dest)->npredecessors)
1034               {
1035                 if (!nextbb)
1036                   nextbb = e->dest;
1037                 else
1038                   BLOCK_INFO (last)->next = e->dest;
1039
1040                 last = e->dest;
1041               }
1042            }
1043     }
1044 }
1045
1046 /* Estimate probabilities of loopback edges in loops at same nest level.  */
1047
1048 static void
1049 estimate_loops_at_level (first_loop)
1050      struct loop *first_loop;
1051 {
1052   struct loop *loop;
1053
1054   for (loop = first_loop; loop; loop = loop->next)
1055     {
1056       edge e;
1057       basic_block *bbs;
1058       int i;
1059
1060       estimate_loops_at_level (loop->inner);
1061
1062       if (loop->latch->succ)  /* Do not do this for dummy function loop.  */
1063         {
1064           /* Find current loop back edge and mark it.  */
1065           e = loop_latch_edge (loop);
1066           EDGE_INFO (e)->back_edge = 1;
1067        }
1068
1069       bbs = get_loop_body (loop);
1070       for (i = 0; i < loop->num_nodes; i++)
1071         BLOCK_INFO (bbs[i])->tovisit = 1;
1072       free (bbs);
1073       propagate_freq (loop);
1074     }
1075 }
1076
1077 /* Convert counts measured by profile driven feedback to frequencies.  */
1078
1079 static void
1080 counts_to_freqs ()
1081 {
1082   gcov_type count_max = 1;
1083   basic_block bb;
1084
1085   FOR_EACH_BB (bb)
1086     count_max = MAX (bb->count, count_max);
1087
1088   FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR, NULL, next_bb)
1089     bb->frequency = (bb->count * BB_FREQ_MAX + count_max / 2) / count_max;
1090 }
1091
1092 /* Return true if function is likely to be expensive, so there is no point to
1093    optimize performance of prologue, epilogue or do inlining at the expense
1094    of code size growth.  THRESHOLD is the limit of number of isntructions
1095    function can execute at average to be still considered not expensive.  */
1096
1097 bool
1098 expensive_function_p (threshold)
1099         int threshold;
1100 {
1101   unsigned int sum = 0;
1102   basic_block bb;
1103   unsigned int limit;
1104
1105   /* We can not compute accurately for large thresholds due to scaled
1106      frequencies.  */
1107   if (threshold > BB_FREQ_MAX)
1108     abort ();
1109
1110   /* Frequencies are out of range.  This either means that function contains
1111      internal loop executing more than BB_FREQ_MAX times or profile feedback
1112      is available and function has not been executed at all.  */
1113   if (ENTRY_BLOCK_PTR->frequency == 0)
1114     return true;
1115
1116   /* Maximally BB_FREQ_MAX^2 so overflow won't happen.  */
1117   limit = ENTRY_BLOCK_PTR->frequency * threshold;
1118   FOR_EACH_BB (bb)
1119     {
1120       rtx insn;
1121
1122       for (insn = bb->head; insn != NEXT_INSN (bb->end);
1123            insn = NEXT_INSN (insn))
1124         if (active_insn_p (insn))
1125           {
1126             sum += bb->frequency;
1127             if (sum > limit)
1128               return true;
1129         }
1130     }
1131
1132   return false;
1133 }
1134
1135 /* Estimate basic blocks frequency by given branch probabilities.  */
1136
1137 static void
1138 estimate_bb_frequencies (loops)
1139      struct loops *loops;
1140 {
1141   basic_block bb;
1142   REAL_VALUE_TYPE freq_max;
1143   enum machine_mode double_mode = TYPE_MODE (double_type_node);
1144
1145   if (flag_branch_probabilities)
1146     counts_to_freqs ();
1147   else
1148     {
1149       REAL_VALUE_FROM_INT (real_zero, 0, 0, double_mode);
1150       REAL_VALUE_FROM_INT (real_one, 1, 0, double_mode);
1151       REAL_VALUE_FROM_INT (real_br_prob_base, REG_BR_PROB_BASE, 0, double_mode);
1152       REAL_VALUE_FROM_INT (real_bb_freq_max, BB_FREQ_MAX, 0, double_mode);
1153       REAL_VALUE_FROM_INT (real_one_half, 2, 0, double_mode);
1154
1155       REAL_ARITHMETIC (real_one_half, RDIV_EXPR, real_one, real_one_half);
1156
1157       REAL_ARITHMETIC (real_almost_one, RDIV_EXPR, real_one, real_br_prob_base);
1158       REAL_ARITHMETIC (real_almost_one, MINUS_EXPR, real_one, real_almost_one);
1159
1160       mark_dfs_back_edges ();
1161       /* Fill in the probability values in flowgraph based on the REG_BR_PROB
1162          notes.  */
1163       FOR_EACH_BB (bb)
1164         {
1165           rtx last_insn = bb->end;
1166
1167           if (!can_predict_insn_p (last_insn))
1168             {
1169               /* We can predict only conditional jumps at the moment.
1170                  Expect each edge to be equally probable.
1171                  ?? In the future we want to make abnormal edges improbable.  */
1172               int nedges = 0;
1173               edge e;
1174
1175               for (e = bb->succ; e; e = e->succ_next)
1176                 {
1177                   nedges++;
1178                   if (e->probability != 0)
1179                     break;
1180                 }
1181               if (!e)
1182                 for (e = bb->succ; e; e = e->succ_next)
1183                   e->probability = (REG_BR_PROB_BASE + nedges / 2) / nedges;
1184             }
1185         }
1186
1187       ENTRY_BLOCK_PTR->succ->probability = REG_BR_PROB_BASE;
1188
1189       /* Set up block info for each basic block.  */
1190       alloc_aux_for_blocks (sizeof (struct block_info_def));
1191       alloc_aux_for_edges (sizeof (struct edge_info_def));
1192       FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR, NULL, next_bb)
1193         {
1194           edge e;
1195
1196           BLOCK_INFO (bb)->tovisit = 0;
1197           for (e = bb->succ; e; e = e->succ_next)
1198             {
1199               REAL_VALUE_FROM_INT (EDGE_INFO (e)->back_edge_prob,
1200                                    e->probability, 0, double_mode);
1201               REAL_ARITHMETIC (EDGE_INFO (e)->back_edge_prob,
1202                                RDIV_EXPR, EDGE_INFO (e)->back_edge_prob,
1203                                real_br_prob_base);
1204             }
1205         }
1206
1207       /* First compute probabilities locally for each loop from innermost
1208          to outermost to examine probabilities for back edges.  */
1209       estimate_loops_at_level (loops->tree_root);
1210
1211       memcpy (&freq_max, &real_zero, sizeof (real_zero));
1212       FOR_EACH_BB (bb)
1213         if (REAL_VALUES_LESS
1214             (freq_max, BLOCK_INFO (bb)->frequency))
1215           memcpy (&freq_max, &BLOCK_INFO (bb)->frequency,
1216                   sizeof (freq_max));
1217
1218       FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR, NULL, next_bb)
1219         {
1220           REAL_VALUE_TYPE tmp;
1221
1222           REAL_ARITHMETIC (tmp, MULT_EXPR, BLOCK_INFO (bb)->frequency,
1223                            real_bb_freq_max);
1224           REAL_ARITHMETIC (tmp, RDIV_EXPR, tmp, freq_max);
1225           REAL_ARITHMETIC (tmp, PLUS_EXPR, tmp, real_one_half);
1226           bb->frequency = REAL_VALUE_UNSIGNED_FIX (tmp);
1227         }
1228
1229       free_aux_for_blocks ();
1230       free_aux_for_edges ();
1231     }
1232   compute_function_frequency ();
1233   if (flag_reorder_functions)
1234     choose_function_section ();
1235 }
1236
1237 /* Decide whether function is hot, cold or unlikely executed.  */
1238 static void
1239 compute_function_frequency ()
1240 {
1241   basic_block bb;
1242
1243   if (!profile_info.count_profiles_merged
1244       || !flag_branch_probabilities)
1245     return;
1246   cfun->function_frequency = FUNCTION_FREQUENCY_UNLIKELY_EXECUTED;
1247   FOR_EACH_BB (bb)
1248     {
1249       if (maybe_hot_bb_p (bb))
1250         {
1251           cfun->function_frequency = FUNCTION_FREQUENCY_HOT;
1252           return;
1253         }
1254       if (!probably_never_executed_bb_p (bb))
1255         cfun->function_frequency = FUNCTION_FREQUENCY_NORMAL;
1256     }
1257 }
1258
1259 /* Choose appropriate section for the function.  */
1260 static void
1261 choose_function_section ()
1262 {
1263   if (DECL_SECTION_NAME (current_function_decl)
1264       || !targetm.have_named_sections
1265       /* Theoretically we can split the gnu.linkonce text section too,
1266          but this requires more work as the frequency needs to match
1267          for all generated objects so we need to merge the frequency
1268          of all instances.  For now just never set frequency for these.  */
1269       || !DECL_ONE_ONLY (current_function_decl))
1270     return;
1271   if (cfun->function_frequency == FUNCTION_FREQUENCY_HOT)
1272     DECL_SECTION_NAME (current_function_decl) =
1273       build_string (strlen (HOT_TEXT_SECTION_NAME), HOT_TEXT_SECTION_NAME);
1274   if (cfun->function_frequency == FUNCTION_FREQUENCY_UNLIKELY_EXECUTED)
1275     DECL_SECTION_NAME (current_function_decl) =
1276       build_string (strlen (UNLIKELY_EXECUTED_TEXT_SECTION_NAME),
1277                     UNLIKELY_EXECUTED_TEXT_SECTION_NAME);
1278 }