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

           Branch data     Line data    Source code
       1                 :            : /* Hooks for cfg representation specific functions.
       2                 :            :    Copyright (C) 2003-2020 Free Software Foundation, Inc.
       3                 :            :    Contributed by Sebastian Pop <s.pop@laposte.net>
       4                 :            : 
       5                 :            : This file is part of GCC.
       6                 :            : 
       7                 :            : GCC is free software; you can redistribute it and/or modify
       8                 :            : it under the terms of the GNU General Public License as published by
       9                 :            : the Free Software Foundation; either version 3, or (at your option)
      10                 :            : any later version.
      11                 :            : 
      12                 :            : GCC is distributed in the hope that it will be useful,
      13                 :            : but WITHOUT ANY WARRANTY; without even the implied warranty of
      14                 :            : MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      15                 :            : GNU General Public License for more details.
      16                 :            : 
      17                 :            : You should have received a copy of the GNU General Public License
      18                 :            : along with GCC; see the file COPYING3.  If not see
      19                 :            : <http://www.gnu.org/licenses/>.  */
      20                 :            : 
      21                 :            : #ifndef GCC_CFGHOOKS_H
      22                 :            : #define GCC_CFGHOOKS_H
      23                 :            : 
      24                 :            : #include "predict.h"
      25                 :            : 
      26                 :            : /* Structure to gather statistic about profile consistency, per pass.
      27                 :            :    An array of this structure, indexed by pass static number, is allocated
      28                 :            :    in passes.c.  The structure is defined here so that different CFG modes
      29                 :            :    can do their book-keeping via CFG hooks.
      30                 :            : 
      31                 :            :    For every field[2], field[0] is the count before the pass runs, and
      32                 :            :    field[1] is the post-pass count.  This allows us to monitor the effect
      33                 :            :    of each individual pass on the profile consistency.
      34                 :            :    
      35                 :            :    This structure is not supposed to be used by anything other than passes.c
      36                 :            :    and one CFG hook per CFG mode.  */
      37                 :            : struct profile_record
      38                 :            : {
      39                 :            :   /* The number of basic blocks where sum(freq) of the block's predecessors
      40                 :            :      doesn't match reasonably well with the incoming frequency.  */
      41                 :            :   int num_mismatched_freq_in;
      42                 :            :   /* Likewise for a basic block's successors.  */
      43                 :            :   int num_mismatched_freq_out;
      44                 :            :   /* The number of basic blocks where sum(count) of the block's predecessors
      45                 :            :      doesn't match reasonably well with the incoming frequency.  */
      46                 :            :   int num_mismatched_count_in;
      47                 :            :   /* Likewise for a basic block's successors.  */
      48                 :            :   int num_mismatched_count_out;
      49                 :            :   /* A weighted cost of the run-time of the function body.  */
      50                 :            :   gcov_type_unsigned time;
      51                 :            :   /* A weighted cost of the size of the function body.  */
      52                 :            :   int size;
      53                 :            :   /* True iff this pass actually was run.  */
      54                 :            :   bool run;
      55                 :            : };
      56                 :            : 
      57                 :            : typedef int_hash <unsigned short, 0> dependence_hash;
      58                 :            : 
      59                 :            : /* Optional data for duplicate_block.   */
      60                 :            : 
      61                 :            : class copy_bb_data
      62                 :            : {
      63                 :            : public:
      64                 :     772177 :   copy_bb_data() : dependence_map (NULL) {}
      65                 :     774741 :   ~copy_bb_data () { delete dependence_map; }
      66                 :            : 
      67                 :            :   /* A map from the copied BBs dependence info cliques to
      68                 :            :      equivalents in the BBs duplicated to.  */
      69                 :            :   hash_map<dependence_hash, unsigned short> *dependence_map;
      70                 :            : };
      71                 :            : 
      72                 :            : struct cfg_hooks
      73                 :            : {
      74                 :            :   /* Name of the corresponding ir.  */
      75                 :            :   const char *name;
      76                 :            : 
      77                 :            :   /* Debugging.  */
      78                 :            :   int (*verify_flow_info) (void);
      79                 :            :   void (*dump_bb) (FILE *, basic_block, int, dump_flags_t);
      80                 :            :   void (*dump_bb_for_graph) (pretty_printer *, basic_block);
      81                 :            : 
      82                 :            :   /* Basic CFG manipulation.  */
      83                 :            : 
      84                 :            :   /* Return new basic block.  */
      85                 :            :   basic_block (*create_basic_block) (void *head, void *end, basic_block after);
      86                 :            : 
      87                 :            :   /* Redirect edge E to the given basic block B and update underlying program
      88                 :            :      representation.  Returns edge representing redirected branch (that may not
      89                 :            :      be equivalent to E in the case of duplicate edges being removed) or NULL
      90                 :            :      if edge is not easily redirectable for whatever reason.  */
      91                 :            :   edge (*redirect_edge_and_branch) (edge e, basic_block b);
      92                 :            : 
      93                 :            :   /* Same as the above but allows redirecting of fallthru edges.  In that case
      94                 :            :      newly created forwarder basic block is returned.  The edge must
      95                 :            :      not be abnormal.  */
      96                 :            :   basic_block (*redirect_edge_and_branch_force) (edge, basic_block);
      97                 :            : 
      98                 :            :   /* Returns true if it is possible to remove the edge by redirecting it
      99                 :            :      to the destination of the other edge going from its source.  */
     100                 :            :   bool (*can_remove_branch_p) (const_edge);
     101                 :            : 
     102                 :            :   /* Remove statements corresponding to a given basic block.  */
     103                 :            :   void (*delete_basic_block) (basic_block);
     104                 :            : 
     105                 :            :   /* Creates a new basic block just after basic block B by splitting
     106                 :            :      everything after specified instruction I.  */
     107                 :            :   basic_block (*split_block) (basic_block b, void * i);
     108                 :            : 
     109                 :            :   /* Move block B immediately after block A.  */
     110                 :            :   bool (*move_block_after) (basic_block b, basic_block a);
     111                 :            : 
     112                 :            :   /* Return true when blocks A and B can be merged into single basic block.  */
     113                 :            :   bool (*can_merge_blocks_p) (basic_block a, basic_block b);
     114                 :            : 
     115                 :            :   /* Merge blocks A and B.  */
     116                 :            :   void (*merge_blocks) (basic_block a, basic_block b);
     117                 :            : 
     118                 :            :   /* Predict edge E using PREDICTOR to given PROBABILITY.  */
     119                 :            :   void (*predict_edge) (edge e, enum br_predictor predictor, int probability);
     120                 :            : 
     121                 :            :   /* Return true if the one of outgoing edges is already predicted by
     122                 :            :      PREDICTOR.  */
     123                 :            :   bool (*predicted_by_p) (const_basic_block bb, enum br_predictor predictor);
     124                 :            : 
     125                 :            :   /* Return true when block A can be duplicated.  */
     126                 :            :   bool (*can_duplicate_block_p) (const_basic_block a);
     127                 :            : 
     128                 :            :   /* Duplicate block A.  */
     129                 :            :   basic_block (*duplicate_block) (basic_block a, copy_bb_data *);
     130                 :            : 
     131                 :            :   /* Higher level functions representable by primitive operations above if
     132                 :            :      we didn't have some oddities in RTL and Tree representations.  */
     133                 :            :   basic_block (*split_edge) (edge);
     134                 :            :   void (*make_forwarder_block) (edge);
     135                 :            : 
     136                 :            :   /* Try to make the edge fallthru.  */
     137                 :            :   void (*tidy_fallthru_edge) (edge);
     138                 :            : 
     139                 :            :   /* Make the edge non-fallthru.  */
     140                 :            :   basic_block (*force_nonfallthru) (edge);
     141                 :            : 
     142                 :            :   /* Say whether a block ends with a call, possibly followed by some
     143                 :            :      other code that must stay with the call.  */
     144                 :            :   bool (*block_ends_with_call_p) (basic_block);
     145                 :            : 
     146                 :            :   /* Say whether a block ends with a conditional branch.  Switches
     147                 :            :      and unconditional branches do not qualify.  */
     148                 :            :   bool (*block_ends_with_condjump_p) (const_basic_block);
     149                 :            : 
     150                 :            :   /* Add fake edges to the function exit for any non constant and non noreturn
     151                 :            :      calls, volatile inline assembly in the bitmap of blocks specified by
     152                 :            :      BLOCKS or to the whole CFG if BLOCKS is zero.  Return the number of blocks
     153                 :            :      that were split.
     154                 :            : 
     155                 :            :      The goal is to expose cases in which entering a basic block does not imply
     156                 :            :      that all subsequent instructions must be executed.  */
     157                 :            :   int (*flow_call_edges_add) (sbitmap);
     158                 :            : 
     159                 :            :   /* This function is called immediately after edge E is added to the
     160                 :            :      edge vector E->dest->preds.  */
     161                 :            :   void (*execute_on_growing_pred) (edge);
     162                 :            : 
     163                 :            :   /* This function is called immediately before edge E is removed from
     164                 :            :      the edge vector E->dest->preds.  */
     165                 :            :   void (*execute_on_shrinking_pred) (edge);
     166                 :            : 
     167                 :            :   /* A hook for duplicating loop in CFG, currently this is used
     168                 :            :      in loop versioning.  */
     169                 :            :   bool (*cfg_hook_duplicate_loop_to_header_edge) (class loop *, edge,
     170                 :            :                                                   unsigned, sbitmap,
     171                 :            :                                                   edge, vec<edge> *,
     172                 :            :                                                   int);
     173                 :            : 
     174                 :            :   /* Add condition to new basic block and update CFG used in loop
     175                 :            :      versioning.  */
     176                 :            :   void (*lv_add_condition_to_bb) (basic_block, basic_block, basic_block,
     177                 :            :                                   void *);
     178                 :            :   /* Update the PHI nodes in case of loop versioning.  */
     179                 :            :   void (*lv_adjust_loop_header_phi) (basic_block, basic_block,
     180                 :            :                                      basic_block, edge);
     181                 :            : 
     182                 :            :   /* Given a condition BB extract the true/false taken/not taken edges
     183                 :            :      (depending if we are on tree's or RTL). */
     184                 :            :   void (*extract_cond_bb_edges) (basic_block, edge *, edge *);
     185                 :            : 
     186                 :            : 
     187                 :            :   /* Add PHI arguments queued in PENDINT_STMT list on edge E to edge
     188                 :            :      E->dest (only in tree-ssa loop versioning.  */
     189                 :            :   void (*flush_pending_stmts) (edge);
     190                 :            :   
     191                 :            :   /* True if a block contains no executable instructions.  */
     192                 :            :   bool (*empty_block_p) (basic_block);
     193                 :            : 
     194                 :            :   /* Split a basic block if it ends with a conditional branch and if
     195                 :            :      the other part of the block is not empty.  */
     196                 :            :   basic_block (*split_block_before_cond_jump) (basic_block);
     197                 :            : 
     198                 :            :   /* Do book-keeping of a basic block for the profile consistency checker.  */
     199                 :            :   void (*account_profile_record) (basic_block, struct profile_record *);
     200                 :            : };
     201                 :            : 
     202                 :            : extern void verify_flow_info (void);
     203                 :            : 
     204                 :            : /* Check control flow invariants, if internal consistency checks are
     205                 :            :    enabled.  */
     206                 :            : 
     207                 :            : static inline void
     208                 :   27712888 : checking_verify_flow_info (void)
     209                 :            : {
     210                 :            :   /* TODO: Add a separate option for -fchecking=cfg.  */
     211                 :   27712888 :   if (flag_checking)
     212                 :   27712500 :     verify_flow_info ();
     213                 :            : }
     214                 :            : 
     215                 :            : extern void dump_bb (FILE *, basic_block, int, dump_flags_t);
     216                 :            : extern void dump_bb_for_graph (pretty_printer *, basic_block);
     217                 :            : extern void dump_flow_info (FILE *, dump_flags_t);
     218                 :            : 
     219                 :            : extern edge redirect_edge_and_branch (edge, basic_block);
     220                 :            : extern basic_block redirect_edge_and_branch_force (edge, basic_block);
     221                 :            : extern edge redirect_edge_succ_nodup (edge, basic_block);
     222                 :            : extern bool can_remove_branch_p (const_edge);
     223                 :            : extern void remove_branch (edge);
     224                 :            : extern void remove_edge (edge);
     225                 :            : extern edge split_block (basic_block, rtx);
     226                 :            : extern edge split_block (basic_block, gimple *);
     227                 :            : extern edge split_block_after_labels (basic_block);
     228                 :            : extern bool move_block_after (basic_block, basic_block);
     229                 :            : extern void delete_basic_block (basic_block);
     230                 :            : extern basic_block split_edge (edge);
     231                 :            : extern basic_block create_basic_block (rtx, rtx, basic_block);
     232                 :            : extern basic_block create_basic_block (gimple_seq, basic_block);
     233                 :            : extern basic_block create_empty_bb (basic_block);
     234                 :            : extern bool can_merge_blocks_p (basic_block, basic_block);
     235                 :            : extern void merge_blocks (basic_block, basic_block);
     236                 :            : extern edge make_forwarder_block (basic_block, bool (*)(edge),
     237                 :            :                                   void (*) (basic_block));
     238                 :            : extern basic_block force_nonfallthru (edge);
     239                 :            : extern void tidy_fallthru_edge (edge);
     240                 :            : extern void tidy_fallthru_edges (void);
     241                 :            : extern void predict_edge (edge e, enum br_predictor predictor, int probability);
     242                 :            : extern bool predicted_by_p (const_basic_block bb, enum br_predictor predictor);
     243                 :            : extern bool can_duplicate_block_p (const_basic_block);
     244                 :            : extern basic_block duplicate_block (basic_block, edge, basic_block,
     245                 :            :                                     copy_bb_data * = NULL);
     246                 :            : extern bool block_ends_with_call_p (basic_block bb);
     247                 :            : extern bool empty_block_p (basic_block);
     248                 :            : extern basic_block split_block_before_cond_jump (basic_block);
     249                 :            : extern bool block_ends_with_condjump_p (const_basic_block bb);
     250                 :            : extern int flow_call_edges_add (sbitmap);
     251                 :            : extern void execute_on_growing_pred (edge);
     252                 :            : extern void execute_on_shrinking_pred (edge);
     253                 :            : extern bool cfg_hook_duplicate_loop_to_header_edge (class loop *loop, edge,
     254                 :            :                                                     unsigned int ndupl,
     255                 :            :                                                     sbitmap wont_exit,
     256                 :            :                                                     edge orig,
     257                 :            :                                                     vec<edge> *to_remove,
     258                 :            :                                                     int flags);
     259                 :            : 
     260                 :            : extern void lv_flush_pending_stmts (edge);
     261                 :            : extern void extract_cond_bb_edges (basic_block, edge *, edge*);
     262                 :            : extern void lv_adjust_loop_header_phi (basic_block, basic_block, basic_block,
     263                 :            :                                        edge);
     264                 :            : extern void lv_add_condition_to_bb (basic_block, basic_block, basic_block,
     265                 :            :                                     void *);
     266                 :            : 
     267                 :            : extern bool can_copy_bbs_p (basic_block *, unsigned);
     268                 :            : extern void copy_bbs (basic_block *, unsigned, basic_block *,
     269                 :            :                       edge *, unsigned, edge *, class loop *,
     270                 :            :                       basic_block, bool);
     271                 :            : 
     272                 :            : void profile_record_check_consistency (profile_record *);
     273                 :            : void profile_record_account_profile (profile_record *);
     274                 :            : 
     275                 :            : /* Hooks containers.  */
     276                 :            : extern struct cfg_hooks gimple_cfg_hooks;
     277                 :            : extern struct cfg_hooks rtl_cfg_hooks;
     278                 :            : extern struct cfg_hooks cfg_layout_rtl_cfg_hooks;
     279                 :            : 
     280                 :            : /* Declarations.  */
     281                 :            : extern enum ir_type current_ir_type (void);
     282                 :            : extern void rtl_register_cfg_hooks (void);
     283                 :            : extern void cfg_layout_rtl_register_cfg_hooks (void);
     284                 :            : extern void gimple_register_cfg_hooks (void);
     285                 :            : extern struct cfg_hooks get_cfg_hooks (void);
     286                 :            : extern void set_cfg_hooks (struct cfg_hooks);
     287                 :            : 
     288                 :            : #endif /* GCC_CFGHOOKS_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.