LCOV - code coverage report
Current view: top level - gcc - cfghooks.h (source / functions) Coverage Total Hit
Test: gcc.info Lines: 100.0 % 5 5
Test Date: 2024-03-23 14:05:01 Functions: 100.0 % 1 1
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-2024 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.cc.  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.cc
      36                 :             :    and one CFG hook per CFG mode.  */
      37                 :             : struct profile_record
      38                 :             : {
      39                 :             :   /* A weighted cost of the run-time of the function body.  */
      40                 :             :   double time;
      41                 :             :   /* Frequency of execution of basic blocks where sum(prob) of the block's
      42                 :             :      predecessors doesn't match reasonably probability 1.  */
      43                 :             :   double dyn_mismatched_prob_out;
      44                 :             :   /* Frequency of execution basic blocks where sum(count) of the block's
      45                 :             :      predecessors doesn't match reasonably well with the incoming frequency.  */
      46                 :             :   double dyn_mismatched_count_in;
      47                 :             :   /* The number of basic blocks where sum(prob) of the block's predecessors
      48                 :             :      doesn't match reasonably probability 1.  */
      49                 :             :   int num_mismatched_prob_out;
      50                 :             :   /* The number of basic blocks where sum(count) of the block's predecessors
      51                 :             :      doesn't match reasonably well with the incoming frequency.  */
      52                 :             :   int num_mismatched_count_in;
      53                 :             :   /* A weighted cost of the size of the function body.  */
      54                 :             :   int size;
      55                 :             :   /* True iff this pass actually was run.  */
      56                 :             :   bool run;
      57                 :             :   bool fdo;
      58                 :             : };
      59                 :             : 
      60                 :             : typedef int_hash <unsigned short, 0> dependence_hash;
      61                 :             : 
      62                 :             : /* Optional data for duplicate_block.   */
      63                 :             : 
      64                 :             : class copy_bb_data
      65                 :             : {
      66                 :             : public:
      67                 :     1882667 :   copy_bb_data() : dependence_map (NULL) {}
      68                 :     1892885 :   ~copy_bb_data () { delete dependence_map; }
      69                 :             : 
      70                 :             :   /* A map from the copied BBs dependence info cliques to
      71                 :             :      equivalents in the BBs duplicated to.  */
      72                 :             :   hash_map<dependence_hash, unsigned short> *dependence_map;
      73                 :             : };
      74                 :             : 
      75                 :             : struct cfg_hooks
      76                 :             : {
      77                 :             :   /* Name of the corresponding ir.  */
      78                 :             :   const char *name;
      79                 :             : 
      80                 :             :   /* Debugging.  */
      81                 :             :   bool (*verify_flow_info) (void);
      82                 :             :   void (*dump_bb) (FILE *, basic_block, int, dump_flags_t);
      83                 :             :   void (*dump_bb_for_graph) (pretty_printer *, basic_block);
      84                 :             : 
      85                 :             :   /* Basic CFG manipulation.  */
      86                 :             : 
      87                 :             :   /* Return new basic block.  */
      88                 :             :   basic_block (*create_basic_block) (void *head, void *end, basic_block after);
      89                 :             : 
      90                 :             :   /* Redirect edge E to the given basic block B and update underlying program
      91                 :             :      representation.  Returns edge representing redirected branch (that may not
      92                 :             :      be equivalent to E in the case of duplicate edges being removed) or NULL
      93                 :             :      if edge is not easily redirectable for whatever reason.  */
      94                 :             :   edge (*redirect_edge_and_branch) (edge e, basic_block b);
      95                 :             : 
      96                 :             :   /* Same as the above but allows redirecting of fallthru edges.  In that case
      97                 :             :      newly created forwarder basic block is returned.  The edge must
      98                 :             :      not be abnormal.  */
      99                 :             :   basic_block (*redirect_edge_and_branch_force) (edge, basic_block);
     100                 :             : 
     101                 :             :   /* Returns true if it is possible to remove the edge by redirecting it
     102                 :             :      to the destination of the other edge going from its source.  */
     103                 :             :   bool (*can_remove_branch_p) (const_edge);
     104                 :             : 
     105                 :             :   /* Remove statements corresponding to a given basic block.  */
     106                 :             :   void (*delete_basic_block) (basic_block);
     107                 :             : 
     108                 :             :   /* Creates a new basic block just after basic block B by splitting
     109                 :             :      everything after specified instruction I.  */
     110                 :             :   basic_block (*split_block) (basic_block b, void * i);
     111                 :             : 
     112                 :             :   /* Move block B immediately after block A.  */
     113                 :             :   bool (*move_block_after) (basic_block b, basic_block a);
     114                 :             : 
     115                 :             :   /* Return true when blocks A and B can be merged into single basic block.  */
     116                 :             :   bool (*can_merge_blocks_p) (basic_block a, basic_block b);
     117                 :             : 
     118                 :             :   /* Merge blocks A and B.  */
     119                 :             :   void (*merge_blocks) (basic_block a, basic_block b);
     120                 :             : 
     121                 :             :   /* Predict edge E using PREDICTOR to given PROBABILITY.  */
     122                 :             :   void (*predict_edge) (edge e, enum br_predictor predictor, int probability);
     123                 :             : 
     124                 :             :   /* Return true if the one of outgoing edges is already predicted by
     125                 :             :      PREDICTOR.  */
     126                 :             :   bool (*predicted_by_p) (const_basic_block bb, enum br_predictor predictor);
     127                 :             : 
     128                 :             :   /* Return true when block A can be duplicated.  */
     129                 :             :   bool (*can_duplicate_block_p) (const_basic_block a);
     130                 :             : 
     131                 :             :   /* Duplicate block A.  */
     132                 :             :   basic_block (*duplicate_block) (basic_block a, copy_bb_data *);
     133                 :             : 
     134                 :             :   /* Higher level functions representable by primitive operations above if
     135                 :             :      we didn't have some oddities in RTL and Tree representations.  */
     136                 :             :   basic_block (*split_edge) (edge);
     137                 :             :   void (*make_forwarder_block) (edge);
     138                 :             : 
     139                 :             :   /* Try to make the edge fallthru.  */
     140                 :             :   void (*tidy_fallthru_edge) (edge);
     141                 :             : 
     142                 :             :   /* Make the edge non-fallthru.  */
     143                 :             :   basic_block (*force_nonfallthru) (edge);
     144                 :             : 
     145                 :             :   /* Say whether a block ends with a call, possibly followed by some
     146                 :             :      other code that must stay with the call.  */
     147                 :             :   bool (*block_ends_with_call_p) (basic_block);
     148                 :             : 
     149                 :             :   /* Say whether a block ends with a conditional branch.  Switches
     150                 :             :      and unconditional branches do not qualify.  */
     151                 :             :   bool (*block_ends_with_condjump_p) (const_basic_block);
     152                 :             : 
     153                 :             :   /* Add fake edges to the function exit for any non constant and non noreturn
     154                 :             :      calls, volatile inline assembly in the bitmap of blocks specified by
     155                 :             :      BLOCKS or to the whole CFG if BLOCKS is zero.  Return the number of blocks
     156                 :             :      that were split.
     157                 :             : 
     158                 :             :      The goal is to expose cases in which entering a basic block does not imply
     159                 :             :      that all subsequent instructions must be executed.  */
     160                 :             :   int (*flow_call_edges_add) (sbitmap);
     161                 :             : 
     162                 :             :   /* This function is called immediately after edge E is added to the
     163                 :             :      edge vector E->dest->preds.  */
     164                 :             :   void (*execute_on_growing_pred) (edge);
     165                 :             : 
     166                 :             :   /* This function is called immediately before edge E is removed from
     167                 :             :      the edge vector E->dest->preds.  */
     168                 :             :   void (*execute_on_shrinking_pred) (edge);
     169                 :             : 
     170                 :             :   /* A hook for duplicating loop in CFG, currently this is used
     171                 :             :      in loop versioning.  */
     172                 :             :   bool (*cfg_hook_duplicate_loop_body_to_header_edge) (class loop *, edge,
     173                 :             :                                                        unsigned, sbitmap, edge,
     174                 :             :                                                        vec<edge> *, int);
     175                 :             : 
     176                 :             :   /* Add condition to new basic block and update CFG used in loop
     177                 :             :      versioning.  */
     178                 :             :   void (*lv_add_condition_to_bb) (basic_block, basic_block, basic_block,
     179                 :             :                                   void *);
     180                 :             :   /* Update the PHI nodes in case of loop versioning.  */
     181                 :             :   void (*lv_adjust_loop_header_phi) (basic_block, basic_block,
     182                 :             :                                      basic_block, edge);
     183                 :             : 
     184                 :             :   /* Given a condition BB extract the true/false taken/not taken edges
     185                 :             :      (depending if we are on tree's or RTL). */
     186                 :             :   void (*extract_cond_bb_edges) (basic_block, edge *, edge *);
     187                 :             : 
     188                 :             : 
     189                 :             :   /* Add PHI arguments queued in PENDINT_STMT list on edge E to edge
     190                 :             :      E->dest (only in tree-ssa loop versioning.  */
     191                 :             :   void (*flush_pending_stmts) (edge);
     192                 :             :   
     193                 :             :   /* True if a block contains no executable instructions.  */
     194                 :             :   bool (*empty_block_p) (basic_block);
     195                 :             : 
     196                 :             :   /* Split a basic block if it ends with a conditional branch and if
     197                 :             :      the other part of the block is not empty.  */
     198                 :             :   basic_block (*split_block_before_cond_jump) (basic_block);
     199                 :             : 
     200                 :             :   /* Do book-keeping of a basic block for the profile consistency checker.  */
     201                 :             :   void (*account_profile_record) (basic_block, struct profile_record *);
     202                 :             : };
     203                 :             : 
     204                 :             : extern void verify_flow_info (void);
     205                 :             : 
     206                 :             : /* Check control flow invariants, if internal consistency checks are
     207                 :             :    enabled.  */
     208                 :             : 
     209                 :             : inline void
     210                 :    43371083 : checking_verify_flow_info (void)
     211                 :             : {
     212                 :             :   /* TODO: Add a separate option for -fchecking=cfg.  */
     213                 :    43371083 :   if (flag_checking)
     214                 :    43370266 :     verify_flow_info ();
     215                 :             : }
     216                 :             : 
     217                 :             : extern void dump_bb (FILE *, basic_block, int, dump_flags_t);
     218                 :             : extern void dump_bb_for_graph (pretty_printer *, basic_block);
     219                 :             : extern void dump_flow_info (FILE *, dump_flags_t);
     220                 :             : 
     221                 :             : extern edge redirect_edge_and_branch (edge, basic_block);
     222                 :             : extern basic_block redirect_edge_and_branch_force (edge, basic_block);
     223                 :             : extern edge redirect_edge_succ_nodup (edge, basic_block);
     224                 :             : extern bool can_remove_branch_p (const_edge);
     225                 :             : extern void remove_branch (edge);
     226                 :             : extern void remove_edge (edge);
     227                 :             : extern edge split_block (basic_block, rtx);
     228                 :             : extern edge split_block (basic_block, gimple *);
     229                 :             : extern edge split_block_after_labels (basic_block);
     230                 :             : extern bool move_block_after (basic_block, basic_block);
     231                 :             : extern void delete_basic_block (basic_block);
     232                 :             : extern basic_block split_edge (edge);
     233                 :             : extern basic_block create_basic_block (rtx, rtx, basic_block);
     234                 :             : extern basic_block create_basic_block (gimple_seq, basic_block);
     235                 :             : extern basic_block create_empty_bb (basic_block);
     236                 :             : extern bool can_merge_blocks_p (basic_block, basic_block);
     237                 :             : extern void merge_blocks (basic_block, basic_block);
     238                 :             : extern edge make_forwarder_block (basic_block, bool (*)(edge),
     239                 :             :                                   void (*) (basic_block));
     240                 :             : extern basic_block force_nonfallthru (edge);
     241                 :             : extern void tidy_fallthru_edge (edge);
     242                 :             : extern void tidy_fallthru_edges (void);
     243                 :             : extern void predict_edge (edge e, enum br_predictor predictor, int probability);
     244                 :             : extern bool predicted_by_p (const_basic_block bb, enum br_predictor predictor);
     245                 :             : extern bool can_duplicate_block_p (const_basic_block);
     246                 :             : extern basic_block duplicate_block (basic_block, edge, basic_block,
     247                 :             :                                     copy_bb_data * = NULL);
     248                 :             : extern bool block_ends_with_call_p (basic_block bb);
     249                 :             : extern bool empty_block_p (basic_block);
     250                 :             : extern basic_block split_block_before_cond_jump (basic_block);
     251                 :             : extern bool block_ends_with_condjump_p (const_basic_block bb);
     252                 :             : extern int flow_call_edges_add (sbitmap);
     253                 :             : extern void execute_on_growing_pred (edge);
     254                 :             : extern void execute_on_shrinking_pred (edge);
     255                 :             : extern bool
     256                 :             : cfg_hook_duplicate_loop_body_to_header_edge (class loop *loop, edge,
     257                 :             :                                              unsigned int ndupl,
     258                 :             :                                              sbitmap wont_exit, edge orig,
     259                 :             :                                              vec<edge> *to_remove, int flags);
     260                 :             : 
     261                 :             : extern void lv_flush_pending_stmts (edge);
     262                 :             : extern void extract_cond_bb_edges (basic_block, edge *, edge*);
     263                 :             : extern void lv_adjust_loop_header_phi (basic_block, basic_block, basic_block,
     264                 :             :                                        edge);
     265                 :             : extern void lv_add_condition_to_bb (basic_block, basic_block, basic_block,
     266                 :             :                                     void *);
     267                 :             : 
     268                 :             : extern bool can_copy_bbs_p (basic_block *, unsigned);
     269                 :             : extern void copy_bbs (basic_block *, unsigned, basic_block *,
     270                 :             :                       edge *, unsigned, edge *, class loop *,
     271                 :             :                       basic_block, bool);
     272                 :             : 
     273                 :             : void profile_record_check_consistency (profile_record *);
     274                 :             : void profile_record_account_profile (profile_record *);
     275                 :             : 
     276                 :             : /* Hooks containers.  */
     277                 :             : extern struct cfg_hooks gimple_cfg_hooks;
     278                 :             : extern struct cfg_hooks rtl_cfg_hooks;
     279                 :             : extern struct cfg_hooks cfg_layout_rtl_cfg_hooks;
     280                 :             : 
     281                 :             : /* Declarations.  */
     282                 :             : extern enum ir_type current_ir_type (void);
     283                 :             : extern void rtl_register_cfg_hooks (void);
     284                 :             : extern void cfg_layout_rtl_register_cfg_hooks (void);
     285                 :             : extern void gimple_register_cfg_hooks (void);
     286                 :             : extern struct cfg_hooks get_cfg_hooks (void);
     287                 :             : extern void set_cfg_hooks (struct cfg_hooks);
     288                 :             : 
     289                 :             : #endif /* GCC_CFGHOOKS_H */
        

Generated by: LCOV version 2.0-1

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,rust,m2 --enable-host-shared. GCC test suite is run with the built compiler.