gcc/basic-block.h

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