gcc/cfganal.h

   1 /* Control flow graph analysis header file.
   2    Copyright (C) 2014-2021 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
  21 #ifndef GCC_CFGANAL_H
  22 #define GCC_CFGANAL_H
  23
  24 /* This structure maintains an edge list vector.  */
  25 /* FIXME: Make this a vec<edge>.  */
  26 struct edge_list
  27 {
  28   int num_edges;
  29   edge *index_to_edge;
  30 };
  31
  32
  33 /* Class to compute and manage control dependences on an edge-list.  */
  34 class control_dependences
  35 {
  36 public:
  37   control_dependences ();
  38   ~control_dependences ();
  39   bitmap get_edges_dependent_on (int);
  40   basic_block get_edge_src (int);
  41   basic_block get_edge_dest (int);
  42
  43 private:
  44   void set_control_dependence_map_bit (basic_block, int);
  45   void clear_control_dependence_bitmap (basic_block);
  46   void find_control_dependence (int);
  47   vec<bitmap_head> control_dependence_map;
  48   vec<std::pair<int, int> > m_el;
  49   bitmap_obstack m_bitmaps;
  50 };
  51
  52 extern bool mark_dfs_back_edges (void);
  53 extern void find_unreachable_blocks (void);
  54 extern void verify_no_unreachable_blocks (void);
  55 struct edge_list * create_edge_list (void);
  56 void free_edge_list (struct edge_list *);
  57 void print_edge_list (FILE *, struct edge_list *);
  58 void verify_edge_list (FILE *, struct edge_list *);
  59 edge find_edge (basic_block, basic_block);
  60 int find_edge_index (struct edge_list *, basic_block, basic_block);
  61 extern void remove_fake_edges (void);
  62 extern void remove_fake_exit_edges (void);
  63 extern void add_noreturn_fake_exit_edges (void);
  64 extern void connect_infinite_loops_to_exit (void);
  65 extern int post_order_compute (int *, bool, bool);
  66 extern basic_block dfs_find_deadend (basic_block);
  67 extern void inverted_post_order_compute (vec<int> *postorder, sbitmap *start_points = 0);
  68 extern int pre_and_rev_post_order_compute_fn (struct function *,
  69                                               int *, int *, bool);
  70 extern int pre_and_rev_post_order_compute (int *, int *, bool);
  71 extern int rev_post_order_and_mark_dfs_back_seme (struct function *, edge,
  72                                                   bitmap, bool, int *,
  73                                                   vec<std::pair<int, int> > *);
  74 extern int dfs_enumerate_from (basic_block, int,
  75                                bool (*)(const_basic_block, const void *),
  76                                basic_block *, int, const void *);
  77 extern void compute_dominance_frontiers (class bitmap_head *);
  78 extern bitmap compute_idf (bitmap, class bitmap_head *);
  79 extern void bitmap_intersection_of_succs (sbitmap, sbitmap *, basic_block);
  80 extern void bitmap_intersection_of_preds (sbitmap, sbitmap *, basic_block);
  81 extern void bitmap_union_of_succs (sbitmap, sbitmap *, basic_block);
  82 extern void bitmap_union_of_preds (sbitmap, sbitmap *, basic_block);
  83 extern basic_block * single_pred_before_succ_order (void);
  84 extern edge single_incoming_edge_ignoring_loop_edges (basic_block, bool);
  85 extern edge single_pred_edge_ignoring_loop_edges (basic_block, bool);
  86
  87
  88 #endif /* GCC_CFGANAL_H */