gcc/cfganal.h

   1 /* Control flow graph analysis header file.
   2    Copyright (C) 2014-2019 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> control_dependence_map;
  48   vec<std::pair<int, int> > m_el;
  49 };
  50
  51 extern bool mark_dfs_back_edges (void);
  52 extern void find_unreachable_blocks (void);
  53 extern void verify_no_unreachable_blocks (void);
  54 struct edge_list * create_edge_list (void);
  55 void free_edge_list (struct edge_list *);
  56 void print_edge_list (FILE *, struct edge_list *);
  57 void verify_edge_list (FILE *, struct edge_list *);
  58 edge find_edge (basic_block, basic_block);
  59 int find_edge_index (struct edge_list *, basic_block, basic_block);
  60 extern void remove_fake_edges (void);
  61 extern void remove_fake_exit_edges (void);
  62 extern void add_noreturn_fake_exit_edges (void);
  63 extern void connect_infinite_loops_to_exit (void);
  64 extern int post_order_compute (int *, bool, bool);
  65 extern basic_block dfs_find_deadend (basic_block);
  66 extern void inverted_post_order_compute (vec<int> *postorder, sbitmap *start_points = 0);
  67 extern int pre_and_rev_post_order_compute_fn (struct function *,
  68                                               int *, int *, bool);
  69 extern int pre_and_rev_post_order_compute (int *, int *, bool);
  70 extern int rev_post_order_and_mark_dfs_back_seme (struct function *, edge,
  71                                                   bitmap, bool, int *);
  72 extern int dfs_enumerate_from (basic_block, int,
  73                                bool (*)(const_basic_block, const void *),
  74                                basic_block *, int, const void *);
  75 extern void compute_dominance_frontiers (class bitmap_head *);
  76 extern bitmap compute_idf (bitmap, class bitmap_head *);
  77 extern void bitmap_intersection_of_succs (sbitmap, sbitmap *, basic_block);
  78 extern void bitmap_intersection_of_preds (sbitmap, sbitmap *, basic_block);
  79 extern void bitmap_union_of_succs (sbitmap, sbitmap *, basic_block);
  80 extern void bitmap_union_of_preds (sbitmap, sbitmap *, basic_block);
  81 extern basic_block * single_pred_before_succ_order (void);
  82 extern edge single_incoming_edge_ignoring_loop_edges (basic_block, bool);
  83 extern edge single_pred_edge_ignoring_loop_edges (basic_block, bool);
  84
  85
  86 #endif /* GCC_CFGANAL_H */