gcc/basic-block.h

   1 /* Define control flow data structures for the CFG.
   2    Copyright (C) 1987-2020 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 #ifndef GCC_BASIC_BLOCK_H
  21 #define GCC_BASIC_BLOCK_H
  22
  23 #include <profile-count.h>
  24
  25 /* Control flow edge information.  */
  26 class GTY((user)) edge_def {
  27 public:
  28   /* The two blocks at the ends of the edge.  */
  29   basic_block src;
  30   basic_block dest;
  31
  32   /* Instructions queued on the edge.  */
  33   union edge_def_insns {
  34     gimple_seq g;
  35     rtx_insn *r;
  36   } insns;
  37
  38   /* Auxiliary info specific to a pass.  */
  39   PTR aux;
  40
  41   /* Location of any goto implicit in the edge.  */
  42   location_t goto_locus;
  43
  44   /* The index number corresponding to this edge in the edge vector
  45      dest->preds.  */
  46   unsigned int dest_idx;
  47
  48   int flags;                    /* see cfg-flags.def */
  49   profile_probability probability;
  50
  51   /* Return count of edge E.  */
  52   inline profile_count count () const;
  53 };
  54
  55 /* Masks for edge.flags.  */
  56 #define DEF_EDGE_FLAG(NAME,IDX) EDGE_##NAME = 1 << IDX ,
  57 enum cfg_edge_flags {
  58 #include "cfg-flags.def"
  59   LAST_CFG_EDGE_FLAG            /* this is only used for EDGE_ALL_FLAGS */
  60 };
  61 #undef DEF_EDGE_FLAG
  62
  63 /* Bit mask for all edge flags.  */
  64 #define EDGE_ALL_FLAGS          ((LAST_CFG_EDGE_FLAG - 1) * 2 - 1)
  65
  66 /* The following four flags all indicate something special about an edge.
  67    Test the edge flags on EDGE_COMPLEX to detect all forms of "strange"
  68    control flow transfers.  */
  69 #define EDGE_COMPLEX \
  70   (EDGE_ABNORMAL | EDGE_ABNORMAL_CALL | EDGE_EH | EDGE_PRESERVE)
  71
  72 struct GTY(()) rtl_bb_info {
  73   /* The first insn of the block is embedded into bb->il.x.  */
  74   /* The last insn of the block.  */
  75   rtx_insn *end_;
  76
  77   /* In CFGlayout mode points to insn notes/jumptables to be placed just before
  78      and after the block.   */
  79   rtx_insn *header_;
  80   rtx_insn *footer_;
  81 };
  82
  83 struct GTY(()) gimple_bb_info {
  84   /* Sequence of statements in this block.  */
  85   gimple_seq seq;
  86
  87   /* PHI nodes for this block.  */
  88   gimple_seq phi_nodes;
  89 };
  90
  91 /* A basic block is a sequence of instructions with only one entry and
  92    only one exit.  If any one of the instructions are executed, they
  93    will all be executed, and in sequence from first to last.
  94
  95    There may be COND_EXEC instructions in the basic block.  The
  96    COND_EXEC *instructions* will be executed -- but if the condition
  97    is false the conditionally executed *expressions* will of course
  98    not be executed.  We don't consider the conditionally executed
  99    expression (which might have side-effects) to be in a separate
 100    basic block because the program counter will always be at the same
 101    location after the COND_EXEC instruction, regardless of whether the
 102    condition is true or not.
 103
 104    Basic blocks need not start with a label nor end with a jump insn.
 105    For example, a previous basic block may just "conditionally fall"
 106    into the succeeding basic block, and the last basic block need not
 107    end with a jump insn.  Block 0 is a descendant of the entry block.
 108
 109    A basic block beginning with two labels cannot have notes between
 110    the labels.
 111
 112    Data for jump tables are stored in jump_insns that occur in no
 113    basic block even though these insns can follow or precede insns in
 114    basic blocks.  */
 115
 116 /* Basic block information indexed by block number.  */
 117 struct GTY((chain_next ("%h.next_bb"), chain_prev ("%h.prev_bb"))) basic_block_def {
 118   /* The edges into and out of the block.  */
 119   vec<edge, va_gc> *preds;
 120   vec<edge, va_gc> *succs;
 121
 122   /* Auxiliary info specific to a pass.  */
 123   PTR GTY ((skip (""))) aux;
 124
 125   /* Innermost loop containing the block.  */
 126   class loop *loop_father;
 127
 128   /* The dominance and postdominance information node.  */
 129   struct et_node * GTY ((skip (""))) dom[2];
 130
 131   /* Previous and next blocks in the chain.  */
 132   basic_block prev_bb;
 133   basic_block next_bb;
 134
 135   union basic_block_il_dependent {
 136       struct gimple_bb_info GTY ((tag ("0"))) gimple;
 137       struct {
 138         rtx_insn *head_;
 139         struct rtl_bb_info * rtl;
 140       } GTY ((tag ("1"))) x;
 141     } GTY ((desc ("((%1.flags & BB_RTL) != 0)"))) il;
 142
 143   /* Various flags.  See cfg-flags.def.  */
 144   int flags;
 145
 146   /* The index of this block.  */
 147   int index;
 148
 149   /* Expected number of executions: calculated in profile.c.  */
 150   profile_count count;
 151
 152   /* The discriminator for this block.  The discriminator distinguishes
 153      among several basic blocks that share a common locus, allowing for
 154      more accurate sample-based profiling.  */
 155   int discriminator;
 156 };
 157
 158 /* This ensures that struct gimple_bb_info is smaller than
 159    struct rtl_bb_info, so that inlining the former into basic_block_def
 160    is the better choice.  */
 161 typedef int __assert_gimple_bb_smaller_rtl_bb
 162               [(int) sizeof (struct rtl_bb_info)
 163                - (int) sizeof (struct gimple_bb_info)];
 164
 165
 166 #define BB_FREQ_MAX 10000
 167
 168 /* Masks for basic_block.flags.  */
 169 #define DEF_BASIC_BLOCK_FLAG(NAME,IDX) BB_##NAME = 1 << IDX ,
 170 enum cfg_bb_flags
 171 {
 172 #include "cfg-flags.def"
 173   LAST_CFG_BB_FLAG              /* this is only used for BB_ALL_FLAGS */
 174 };
 175 #undef DEF_BASIC_BLOCK_FLAG
 176
 177 /* Bit mask for all basic block flags.  */
 178 #define BB_ALL_FLAGS            ((LAST_CFG_BB_FLAG - 1) * 2 - 1)
 179
 180 /* Bit mask for all basic block flags that must be preserved.  These are
 181    the bit masks that are *not* cleared by clear_bb_flags.  */
 182 #define BB_FLAGS_TO_PRESERVE                                    \
 183   (BB_DISABLE_SCHEDULE | BB_RTL | BB_NON_LOCAL_GOTO_TARGET      \
 184    | BB_HOT_PARTITION | BB_COLD_PARTITION)
 185
 186 /* Dummy bitmask for convenience in the hot/cold partitioning code.  */
 187 #define BB_UNPARTITIONED        0
 188
 189 /* Partitions, to be used when partitioning hot and cold basic blocks into
 190    separate sections.  */
 191 #define BB_PARTITION(bb) ((bb)->flags & (BB_HOT_PARTITION|BB_COLD_PARTITION))
 192 #define BB_SET_PARTITION(bb, part) do {                                 \
 193   basic_block bb_ = (bb);                                               \
 194   bb_->flags = ((bb_->flags & ~(BB_HOT_PARTITION|BB_COLD_PARTITION))    \
 195                 | (part));                                              \
 196 } while (0)
 197
 198 #define BB_COPY_PARTITION(dstbb, srcbb) \
 199   BB_SET_PARTITION (dstbb, BB_PARTITION (srcbb))
 200
 201 /* Defines for accessing the fields of the CFG structure for function FN.  */
 202 #define ENTRY_BLOCK_PTR_FOR_FN(FN)           ((FN)->cfg->x_entry_block_ptr)
 203 #define EXIT_BLOCK_PTR_FOR_FN(FN)            ((FN)->cfg->x_exit_block_ptr)
 204 #define basic_block_info_for_fn(FN)          ((FN)->cfg->x_basic_block_info)
 205 #define n_basic_blocks_for_fn(FN)            ((FN)->cfg->x_n_basic_blocks)
 206 #define n_edges_for_fn(FN)                   ((FN)->cfg->x_n_edges)
 207 #define last_basic_block_for_fn(FN)          ((FN)->cfg->x_last_basic_block)
 208 #define label_to_block_map_for_fn(FN)        ((FN)->cfg->x_label_to_block_map)
 209 #define profile_status_for_fn(FN)            ((FN)->cfg->x_profile_status)
 210
 211 #define BASIC_BLOCK_FOR_FN(FN,N) \
 212   ((*basic_block_info_for_fn (FN))[(N)])
 213 #define SET_BASIC_BLOCK_FOR_FN(FN,N,BB) \
 214   ((*basic_block_info_for_fn (FN))[(N)] = (BB))
 215
 216 /* For iterating over basic blocks.  */
 217 #define FOR_BB_BETWEEN(BB, FROM, TO, DIR) \
 218   for (BB = FROM; BB != TO; BB = BB->DIR)
 219
 220 #define FOR_EACH_BB_FN(BB, FN) \
 221   FOR_BB_BETWEEN (BB, (FN)->cfg->x_entry_block_ptr->next_bb, (FN)->cfg->x_exit_block_ptr, next_bb)
 222
 223 #define FOR_EACH_BB_REVERSE_FN(BB, FN) \
 224   FOR_BB_BETWEEN (BB, (FN)->cfg->x_exit_block_ptr->prev_bb, (FN)->cfg->x_entry_block_ptr, prev_bb)
 225
 226 /* For iterating over insns in basic block.  */
 227 #define FOR_BB_INSNS(BB, INSN)                  \
 228   for ((INSN) = BB_HEAD (BB);                   \
 229        (INSN) && (INSN) != NEXT_INSN (BB_END (BB));     \
 230        (INSN) = NEXT_INSN (INSN))
 231
 232 /* For iterating over insns in basic block when we might remove the
 233    current insn.  */
 234 #define FOR_BB_INSNS_SAFE(BB, INSN, CURR)                       \
 235   for ((INSN) = BB_HEAD (BB), (CURR) = (INSN) ? NEXT_INSN ((INSN)): NULL;       \
 236        (INSN) && (INSN) != NEXT_INSN (BB_END (BB));     \
 237        (INSN) = (CURR), (CURR) = (INSN) ? NEXT_INSN ((INSN)) : NULL)
 238
 239 #define FOR_BB_INSNS_REVERSE(BB, INSN)          \
 240   for ((INSN) = BB_END (BB);                    \
 241        (INSN) && (INSN) != PREV_INSN (BB_HEAD (BB));    \
 242        (INSN) = PREV_INSN (INSN))
 243
 244 #define FOR_BB_INSNS_REVERSE_SAFE(BB, INSN, CURR)       \
 245   for ((INSN) = BB_END (BB),(CURR) = (INSN) ? PREV_INSN ((INSN)) : NULL;        \
 246        (INSN) && (INSN) != PREV_INSN (BB_HEAD (BB));    \
 247        (INSN) = (CURR), (CURR) = (INSN) ? PREV_INSN ((INSN)) : NULL)
 248
 249 /* Cycles through _all_ basic blocks, even the fake ones (entry and
 250    exit block).  */
 251
 252 #define FOR_ALL_BB_FN(BB, FN) \
 253   for (BB = ENTRY_BLOCK_PTR_FOR_FN (FN); BB; BB = BB->next_bb)
 254
 255 \f
 256 /* Stuff for recording basic block info.  */
 257
 258 /* For now, these will be functions (so that they can include checked casts
 259    to rtx_insn.   Once the underlying fields are converted from rtx
 260    to rtx_insn, these can be converted back to macros.  */
 261
 262 #define BB_HEAD(B)      (B)->il.x.head_
 263 #define BB_END(B)       (B)->il.x.rtl->end_
 264 #define BB_HEADER(B)    (B)->il.x.rtl->header_
 265 #define BB_FOOTER(B)    (B)->il.x.rtl->footer_
 266
 267 /* Special block numbers [markers] for entry and exit.
 268    Neither of them is supposed to hold actual statements.  */
 269 #define ENTRY_BLOCK (0)
 270 #define EXIT_BLOCK (1)
 271
 272 /* The two blocks that are always in the cfg.  */
 273 #define NUM_FIXED_BLOCKS (2)
 274
 275 /* This is the value which indicates no edge is present.  */
 276 #define EDGE_INDEX_NO_EDGE      -1
 277
 278 /* EDGE_INDEX returns an integer index for an edge, or EDGE_INDEX_NO_EDGE
 279    if there is no edge between the 2 basic blocks.  */
 280 #define EDGE_INDEX(el, pred, succ) (find_edge_index ((el), (pred), (succ)))
 281
 282 /* INDEX_EDGE_PRED_BB and INDEX_EDGE_SUCC_BB return a pointer to the basic
 283    block which is either the pred or succ end of the indexed edge.  */
 284 #define INDEX_EDGE_PRED_BB(el, index)   ((el)->index_to_edge[(index)]->src)
 285 #define INDEX_EDGE_SUCC_BB(el, index)   ((el)->index_to_edge[(index)]->dest)
 286
 287 /* INDEX_EDGE returns a pointer to the edge.  */
 288 #define INDEX_EDGE(el, index)           ((el)->index_to_edge[(index)])
 289
 290 /* Number of edges in the compressed edge list.  */
 291 #define NUM_EDGES(el)                   ((el)->num_edges)
 292
 293 /* BB is assumed to contain conditional jump.  Return the fallthru edge.  */
 294 #define FALLTHRU_EDGE(bb)               (EDGE_SUCC ((bb), 0)->flags & EDGE_FALLTHRU \
 295                                          ? EDGE_SUCC ((bb), 0) : EDGE_SUCC ((bb), 1))
 296
 297 /* BB is assumed to contain conditional jump.  Return the branch edge.  */
 298 #define BRANCH_EDGE(bb)                 (EDGE_SUCC ((bb), 0)->flags & EDGE_FALLTHRU \
 299                                          ? EDGE_SUCC ((bb), 1) : EDGE_SUCC ((bb), 0))
 300
 301 /* Return expected execution frequency of the edge E.  */
 302 #define EDGE_FREQUENCY(e)               e->count ().to_frequency (cfun)
 303
 304 /* Compute a scale factor (or probability) suitable for scaling of
 305    gcov_type values via apply_probability() and apply_scale().  */
 306 #define GCOV_COMPUTE_SCALE(num,den) \
 307   ((den) ? RDIV ((num) * REG_BR_PROB_BASE, (den)) : REG_BR_PROB_BASE)
 308
 309 /* Return nonzero if edge is critical.  */
 310 #define EDGE_CRITICAL_P(e)              (EDGE_COUNT ((e)->src->succs) >= 2 \
 311                                          && EDGE_COUNT ((e)->dest->preds) >= 2)
 312
 313 #define EDGE_COUNT(ev)                  vec_safe_length (ev)
 314 #define EDGE_I(ev,i)                    (*ev)[(i)]
 315 #define EDGE_PRED(bb,i)                 (*(bb)->preds)[(i)]
 316 #define EDGE_SUCC(bb,i)                 (*(bb)->succs)[(i)]
 317
 318 /* Returns true if BB has precisely one successor.  */
 319
 320 static inline bool
 321 single_succ_p (const_basic_block bb)
 322 {
 323   return EDGE_COUNT (bb->succs) == 1;
 324 }
 325
 326 /* Returns true if BB has precisely one predecessor.  */
 327
 328 static inline bool
 329 single_pred_p (const_basic_block bb)
 330 {
 331   return EDGE_COUNT (bb->preds) == 1;
 332 }
 333
 334 /* Returns the single successor edge of basic block BB.  Aborts if
 335    BB does not have exactly one successor.  */
 336
 337 static inline edge
 338 single_succ_edge (const_basic_block bb)
 339 {
 340   gcc_checking_assert (single_succ_p (bb));
 341   return EDGE_SUCC (bb, 0);
 342 }
 343
 344 /* Returns the single predecessor edge of basic block BB.  Aborts
 345    if BB does not have exactly one predecessor.  */
 346
 347 static inline edge
 348 single_pred_edge (const_basic_block bb)
 349 {
 350   gcc_checking_assert (single_pred_p (bb));
 351   return EDGE_PRED (bb, 0);
 352 }
 353
 354 /* Returns the single successor block of basic block BB.  Aborts
 355    if BB does not have exactly one successor.  */
 356
 357 static inline basic_block
 358 single_succ (const_basic_block bb)
 359 {
 360   return single_succ_edge (bb)->dest;
 361 }
 362
 363 /* Returns the single predecessor block of basic block BB.  Aborts
 364    if BB does not have exactly one predecessor.*/
 365
 366 static inline basic_block
 367 single_pred (const_basic_block bb)
 368 {
 369   return single_pred_edge (bb)->src;
 370 }
 371
 372 /* Iterator object for edges.  */
 373
 374 struct edge_iterator {
 375   unsigned index;
 376   vec<edge, va_gc> **container;
 377 };
 378
 379 static inline vec<edge, va_gc> *
 380 ei_container (edge_iterator i)
 381 {
 382   gcc_checking_assert (i.container);
 383   return *i.container;
 384 }
 385
 386 #define ei_start(iter) ei_start_1 (&(iter))
 387 #define ei_last(iter) ei_last_1 (&(iter))
 388
 389 /* Return an iterator pointing to the start of an edge vector.  */
 390 static inline edge_iterator
 391 ei_start_1 (vec<edge, va_gc> **ev)
 392 {
 393   edge_iterator i;
 394
 395   i.index = 0;
 396   i.container = ev;
 397
 398   return i;
 399 }
 400
 401 /* Return an iterator pointing to the last element of an edge
 402    vector.  */
 403 static inline edge_iterator
 404 ei_last_1 (vec<edge, va_gc> **ev)
 405 {
 406   edge_iterator i;
 407
 408   i.index = EDGE_COUNT (*ev) - 1;
 409   i.container = ev;
 410
 411   return i;
 412 }
 413
 414 /* Is the iterator `i' at the end of the sequence?  */
 415 static inline bool
 416 ei_end_p (edge_iterator i)
 417 {
 418   return (i.index == EDGE_COUNT (ei_container (i)));
 419 }
 420
 421 /* Is the iterator `i' at one position before the end of the
 422    sequence?  */
 423 static inline bool
 424 ei_one_before_end_p (edge_iterator i)
 425 {
 426   return (i.index + 1 == EDGE_COUNT (ei_container (i)));
 427 }
 428
 429 /* Advance the iterator to the next element.  */
 430 static inline void
 431 ei_next (edge_iterator *i)
 432 {
 433   gcc_checking_assert (i->index < EDGE_COUNT (ei_container (*i)));
 434   i->index++;
 435 }
 436
 437 /* Move the iterator to the previous element.  */
 438 static inline void
 439 ei_prev (edge_iterator *i)
 440 {
 441   gcc_checking_assert (i->index > 0);
 442   i->index--;
 443 }
 444
 445 /* Return the edge pointed to by the iterator `i'.  */
 446 static inline edge
 447 ei_edge (edge_iterator i)
 448 {
 449   return EDGE_I (ei_container (i), i.index);
 450 }
 451
 452 /* Return an edge pointed to by the iterator.  Do it safely so that
 453    NULL is returned when the iterator is pointing at the end of the
 454    sequence.  */
 455 static inline edge
 456 ei_safe_edge (edge_iterator i)
 457 {
 458   return !ei_end_p (i) ? ei_edge (i) : NULL;
 459 }
 460
 461 /* Return 1 if we should continue to iterate.  Return 0 otherwise.
 462    *Edge P is set to the next edge if we are to continue to iterate
 463    and NULL otherwise.  */
 464
 465 static inline bool
 466 ei_cond (edge_iterator ei, edge *p)
 467 {
 468   if (!ei_end_p (ei))
 469     {
 470       *p = ei_edge (ei);
 471       return 1;
 472     }
 473   else
 474     {
 475       *p = NULL;
 476       return 0;
 477     }
 478 }
 479
 480 /* This macro serves as a convenient way to iterate each edge in a
 481    vector of predecessor or successor edges.  It must not be used when
 482    an element might be removed during the traversal, otherwise
 483    elements will be missed.  Instead, use a for-loop like that shown
 484    in the following pseudo-code:
 485
 486    FOR (ei = ei_start (bb->succs); (e = ei_safe_edge (ei)); )
 487      {
 488         IF (e != taken_edge)
 489           remove_edge (e);
 490         ELSE
 491           ei_next (&ei);
 492      }
 493 */
 494
 495 #define FOR_EACH_EDGE(EDGE,ITER,EDGE_VEC)       \
 496   for ((ITER) = ei_start ((EDGE_VEC));          \
 497        ei_cond ((ITER), &(EDGE));               \
 498        ei_next (&(ITER)))
 499
 500 #define CLEANUP_EXPENSIVE       1       /* Do relatively expensive optimizations
 501                                            except for edge forwarding */
 502 #define CLEANUP_CROSSJUMP       2       /* Do crossjumping.  */
 503 #define CLEANUP_POST_REGSTACK   4       /* We run after reg-stack and need
 504                                            to care REG_DEAD notes.  */
 505 #define CLEANUP_THREADING       8       /* Do jump threading.  */
 506 #define CLEANUP_NO_INSN_DEL     16      /* Do not try to delete trivially dead
 507                                            insns.  */
 508 #define CLEANUP_CFGLAYOUT       32      /* Do cleanup in cfglayout mode.  */
 509 #define CLEANUP_CFG_CHANGED     64      /* The caller changed the CFG.  */
 510 #define CLEANUP_NO_PARTITIONING 128     /* Do not try to fix partitions.  */
 511 #define CLEANUP_FORCE_FAST_DCE  0x100   /* Force run_fast_dce to be called
 512                                            at least once.  */
 513
 514 /* Return true if BB is in a transaction.  */
 515
 516 static inline bool
 517 bb_in_transaction (basic_block bb)
 518 {
 519   return bb->flags & BB_IN_TRANSACTION;
 520 }
 521
 522 /* Return true when one of the predecessor edges of BB is marked with EDGE_EH.  */
 523 static inline bool
 524 bb_has_eh_pred (basic_block bb)
 525 {
 526   edge e;
 527   edge_iterator ei;
 528
 529   FOR_EACH_EDGE (e, ei, bb->preds)
 530     {
 531       if (e->flags & EDGE_EH)
 532         return true;
 533     }
 534   return false;
 535 }
 536
 537 /* Return true when one of the predecessor edges of BB is marked with EDGE_ABNORMAL.  */
 538 static inline bool
 539 bb_has_abnormal_pred (basic_block bb)
 540 {
 541   edge e;
 542   edge_iterator ei;
 543
 544   FOR_EACH_EDGE (e, ei, bb->preds)
 545     {
 546       if (e->flags & EDGE_ABNORMAL)
 547         return true;
 548     }
 549   return false;
 550 }
 551
 552 /* Return the fallthru edge in EDGES if it exists, NULL otherwise.  */
 553 static inline edge
 554 find_fallthru_edge (vec<edge, va_gc> *edges)
 555 {
 556   edge e;
 557   edge_iterator ei;
 558
 559   FOR_EACH_EDGE (e, ei, edges)
 560     if (e->flags & EDGE_FALLTHRU)
 561       break;
 562
 563   return e;
 564 }
 565
 566 /* Check tha probability is sane.  */
 567
 568 static inline void
 569 check_probability (int prob)
 570 {
 571   gcc_checking_assert (prob >= 0 && prob <= REG_BR_PROB_BASE);
 572 }
 573
 574 /* Given PROB1 and PROB2, return PROB1*PROB2/REG_BR_PROB_BASE.
 575    Used to combine BB probabilities.  */
 576
 577 static inline int
 578 combine_probabilities (int prob1, int prob2)
 579 {
 580   check_probability (prob1);
 581   check_probability (prob2);
 582   return RDIV (prob1 * prob2, REG_BR_PROB_BASE);
 583 }
 584
 585 /* Apply scale factor SCALE on frequency or count FREQ. Use this
 586    interface when potentially scaling up, so that SCALE is not
 587    constrained to be < REG_BR_PROB_BASE.  */
 588
 589 static inline gcov_type
 590 apply_scale (gcov_type freq, gcov_type scale)
 591 {
 592   return RDIV (freq * scale, REG_BR_PROB_BASE);
 593 }
 594
 595 /* Apply probability PROB on frequency or count FREQ.  */
 596
 597 static inline gcov_type
 598 apply_probability (gcov_type freq, int prob)
 599 {
 600   check_probability (prob);
 601   return apply_scale (freq, prob);
 602 }
 603
 604 /* Return inverse probability for PROB.  */
 605
 606 static inline int
 607 inverse_probability (int prob1)
 608 {
 609   check_probability (prob1);
 610   return REG_BR_PROB_BASE - prob1;
 611 }
 612
 613 /* Return true if BB has at least one abnormal outgoing edge.  */
 614
 615 static inline bool
 616 has_abnormal_or_eh_outgoing_edge_p (basic_block bb)
 617 {
 618   edge e;
 619   edge_iterator ei;
 620
 621   FOR_EACH_EDGE (e, ei, bb->succs)
 622     if (e->flags & (EDGE_ABNORMAL | EDGE_EH))
 623       return true;
 624
 625   return false;
 626 }
 627
 628 /* Return true when one of the predecessor edges of BB is marked with
 629    EDGE_ABNORMAL_CALL or EDGE_EH.  */
 630
 631 static inline bool
 632 has_abnormal_call_or_eh_pred_edge_p (basic_block bb)
 633 {
 634   edge e;
 635   edge_iterator ei;
 636
 637   FOR_EACH_EDGE (e, ei, bb->preds)
 638     if (e->flags & (EDGE_ABNORMAL_CALL | EDGE_EH))
 639       return true;
 640
 641   return false;
 642 }
 643
 644 /* Return count of edge E.  */
 645 inline profile_count edge_def::count () const
 646 {
 647   return src->count.apply_probability (probability);
 648 }
 649
 650 #endif /* GCC_BASIC_BLOCK_H */