gcc/basic-block.h

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