LCOV - code coverage report
Current view: top level - gcc - basic-block.h (source / functions) Hit Total Coverage
Test: gcc.info Lines: 63 64 98.4 %
Date: 2020-04-04 11:58:09 Functions: 9 9 100.0 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 0 0 -

           Branch data     Line data    Source code
       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                 :            : 
     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                 : 2151213308 : single_succ_p (const_basic_block bb)
     322                 :            : {
     323                 : 2336981207 :   return EDGE_COUNT (bb->succs) == 1;
     324                 :            : }
     325                 :            : 
     326                 :            : /* Returns true if BB has precisely one predecessor.  */
     327                 :            : 
     328                 :            : static inline bool
     329                 :  688171128 : single_pred_p (const_basic_block bb)
     330                 :            : {
     331                 : 1955336611 :   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                 : 1125117048 : single_succ_edge (const_basic_block bb)
     339                 :            : {
     340                 : 1125117048 :   gcc_checking_assert (single_succ_p (bb));
     341                 : 1125117048 :   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                 :  580787582 : single_pred_edge (const_basic_block bb)
     349                 :            : {
     350                 :  580787582 :   gcc_checking_assert (single_pred_p (bb));
     351                 :  580787582 :   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                 :  752353751 : single_succ (const_basic_block bb)
     359                 :            : {
     360                 :  664508734 :   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                 :  327193497 : single_pred (const_basic_block bb)
     368                 :            : {
     369                 :  326151039 :   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                 :78027613580 : ei_container (edge_iterator i)
     381                 :            : {
     382                 :  388612020 :   gcc_checking_assert (i.container);
     383                 :77827624180 :   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                 :36246223984 : ei_start_1 (vec<edge, va_gc> **ev)
     392                 :            : {
     393                 :36246223984 :   edge_iterator i;
     394                 :            : 
     395                 :36246223984 :   i.index = 0;
     396                 :36246223984 :   i.container = ev;
     397                 :            : 
     398                 :33086362524 :   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                 :26115595095 : ei_end_p (edge_iterator i)
     417                 :            : {
     418                 :52122082358 :   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                 :51523407266 : ei_next (edge_iterator *i)
     432                 :            : {
     433                 :>10304*10^7 :   gcc_checking_assert (i->index < EDGE_COUNT (ei_container (*i)));
     434                 :51523407266 :   i->index++;
     435                 :51523407266 : }
     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                 :      22562 : bb_in_transaction (basic_block bb)
     518                 :            : {
     519                 :      22562 :   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                 :  592860159 : bb_has_eh_pred (basic_block bb)
     525                 :            : {
     526                 :  592860159 :   edge e;
     527                 :  592860159 :   edge_iterator ei;
     528                 :            : 
     529                 : 1424353450 :   FOR_EACH_EDGE (e, ei, bb->preds)
     530                 :            :     {
     531                 :  837988573 :       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                 : 2313700270 : bb_has_abnormal_pred (basic_block bb)
     540                 :            : {
     541                 : 2313700270 :   edge e;
     542                 : 2313700270 :   edge_iterator ei;
     543                 :            : 
     544                 : 5610572500 :   FOR_EACH_EDGE (e, ei, bb->preds)
     545                 :            :     {
     546                 : 3304441400 :       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                 :  414144245 : find_fallthru_edge (vec<edge, va_gc> *edges)
     555                 :            : {
     556                 :  414144245 :   edge e;
     557                 :  414144245 :   edge_iterator ei;
     558                 :            : 
     559                 :  842400082 :   FOR_EACH_EDGE (e, ei, edges)
     560                 :  723196553 :     if (e->flags & EDGE_FALLTHRU)
     561                 :            :       break;
     562                 :            : 
     563                 :  414144245 :   return e;
     564                 :            : }
     565                 :            : 
     566                 :            : /* Check tha probability is sane.  */
     567                 :            : 
     568                 :            : static inline void
     569                 :     520560 : check_probability (int prob)
     570                 :            : {
     571                 :          0 :   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                 :     260280 : combine_probabilities (int prob1, int prob2)
     579                 :            : {
     580                 :     260280 :   check_probability (prob1);
     581                 :     260280 :   check_probability (prob2);
     582                 :     260280 :   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                 :   11452900 : has_abnormal_or_eh_outgoing_edge_p (basic_block bb)
     617                 :            : {
     618                 :   11452900 :   edge e;
     619                 :   11452900 :   edge_iterator ei;
     620                 :            : 
     621                 :   26313900 :   FOR_EACH_EDGE (e, ei, bb->succs)
     622                 :   15962200 :     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                 :     525916 : has_abnormal_call_or_eh_pred_edge_p (basic_block bb)
     633                 :            : {
     634                 :     525916 :   edge e;
     635                 :     525916 :   edge_iterator ei;
     636                 :            : 
     637                 :     528843 :   FOR_EACH_EDGE (e, ei, bb->preds)
     638                 :     526633 :     if (e->flags & (EDGE_ABNORMAL_CALL | EDGE_EH))
     639                 :            :       return true;
     640                 :            : 
     641                 :            :   return false;
     642                 :            : }
     643                 :            : 
     644                 :            : /* Return count of edge E.  */
     645                 :  210307215 : inline profile_count edge_def::count () const
     646                 :            : {
     647                 :  197569890 :   return src->count.apply_probability (probability);
     648                 :            : }
     649                 :            : 
     650                 :            : #endif /* GCC_BASIC_BLOCK_H */

Generated by: LCOV version 1.0

LCOV profile is generated on x86_64 machine using following configure options: configure --disable-bootstrap --enable-coverage=opt --enable-languages=c,c++,fortran,go,jit,lto --enable-host-shared. GCC test suite is run with the built compiler.