gcc/cfghooks.h

   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   copy_bb_data() : dependence_map (NULL) {}
  65   ~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 checking_verify_flow_info (void)
 209 {
 210   /* TODO: Add a separate option for -fchecking=cfg.  */
 211   if (flag_checking)
 212     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 */