Line data    Source code

       1              : /* Data and Control Flow Analysis for Trees.
       2              :    Copyright (C) 2001-2026 Free Software Foundation, Inc.
       3              :    Contributed by Diego Novillo <dnovillo@redhat.com>
       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 _TREE_CFG_H
      22              : #define _TREE_CFG_H
      23              : 
      24              : /* Location to track pending stmt for edge insertion.  */
      25              : #define PENDING_STMT(e) ((e)->insns.g)
      26              : 
      27              : /* Garbage collection and PCH support for edge_def.  */
      28              : extern void gt_ggc_mx (edge_def *e);
      29              : extern void gt_pch_nx (edge_def *e);
      30              : extern void gt_pch_nx (edge_def *e, gt_pointer_operator, void *);
      31              : 
      32              : extern void init_empty_tree_cfg_for_function (struct function *);
      33              : extern void init_empty_tree_cfg (void);
      34              : extern void start_recording_case_labels (void);
      35              : extern void end_recording_case_labels (void);
      36              : extern tree get_cases_for_edge (edge, gswitch *);
      37              : extern basic_block label_to_block (struct function *, tree);
      38              : extern void cleanup_dead_labels (void);
      39              : extern bool group_case_labels_stmt (gswitch *);
      40              : extern bool group_case_labels (void);
      41              : extern void replace_uses_by (tree, tree);
      42              : extern basic_block single_noncomplex_succ (basic_block bb);
      43              : extern void notice_special_calls (gcall *);
      44              : extern void clear_special_calls (void);
      45              : extern edge find_taken_edge (basic_block, tree);
      46              : extern void gimple_debug_bb (basic_block);
      47              : extern basic_block gimple_debug_bb_n (int);
      48              : extern void gimple_debug_cfg (dump_flags_t);
      49              : extern void gimple_dump_cfg (FILE *, dump_flags_t);
      50              : extern void dump_cfg_stats (FILE *);
      51              : extern void debug_cfg_stats (void);
      52              : extern bool computed_goto_p (gimple *);
      53              : extern bool stmt_can_make_abnormal_goto (gimple *);
      54              : extern basic_block get_abnormal_succ_dispatcher (basic_block);
      55              : extern bool is_ctrl_stmt (gimple *);
      56              : extern bool is_ctrl_altering_stmt (gimple *);
      57              : extern bool simple_goto_p (gimple *);
      58              : extern bool stmt_ends_bb_p (gimple *);
      59              : extern bool gimple_seq_unreachable_p (gimple_seq);
      60              : extern bool assert_unreachable_fallthru_edge_p (edge);
      61              : extern void delete_tree_cfg_annotations (function *);
      62              : extern gphi *get_virtual_phi (basic_block);
      63              : extern gimple *first_stmt (basic_block);
      64              : extern gimple *last_nondebug_stmt (basic_block);
      65              : extern gimple *last_and_only_stmt (basic_block);
      66              : extern bool verify_gimple_in_seq (gimple_seq, bool = true);
      67              : extern bool verify_gimple_in_cfg (struct function *, bool, bool = true);
      68              : extern tree gimple_block_label (basic_block);
      69              : extern void add_phi_args_after_copy_bb (basic_block);
      70              : extern void add_phi_args_after_copy (basic_block *, unsigned, edge);
      71              : extern basic_block split_edge_bb_loc (edge);
      72              : extern bool gimple_duplicate_seme_region (edge, edge, basic_block *, unsigned,
      73              :                                           basic_block *, bool);
      74              : extern bool gimple_duplicate_sese_tail (edge, edge, basic_block *, unsigned,
      75              :                                       basic_block *);
      76              : extern void gather_blocks_in_sese_region (basic_block entry, basic_block exit,
      77              :                                           vec<basic_block> *bbs_p);
      78              : extern void verify_sese (basic_block, basic_block, vec<basic_block> *);
      79              : extern bool gather_ssa_name_hash_map_from (tree const &, tree const &, void *);
      80              : extern void fold_loop_internal_call (gimple *, tree);
      81              : extern basic_block move_sese_region_to_fn (struct function *, basic_block,
      82              :                                            basic_block, tree);
      83              : extern void dump_function_to_file (tree, FILE *, dump_flags_t);
      84              : extern void debug_function (tree, dump_flags_t);
      85              : extern void print_loops_bb (FILE *, basic_block, int, int);
      86              : extern void print_loops (FILE *, int);
      87              : extern void debug (class loop &ref);
      88              : extern void debug (class loop *ptr);
      89              : extern void debug_verbose (class loop &ref);
      90              : extern void debug_verbose (class loop *ptr);
      91              : extern void debug_loops (int);
      92              : extern void debug_loop (class loop *, int);
      93              : extern void debug_loop_num (unsigned, int);
      94              : extern void remove_edge_and_dominated_blocks (edge);
      95              : extern bool gimple_purge_dead_eh_edges (basic_block);
      96              : extern bool gimple_purge_all_dead_eh_edges (const_bitmap);
      97              : extern bool gimple_purge_dead_abnormal_call_edges (basic_block);
      98              : extern bool gimple_purge_all_dead_abnormal_call_edges (const_bitmap);
      99              : extern void extract_true_false_edges_from_block (basic_block, edge *, edge *);
     100              : extern tree find_case_label_for_value (const gswitch *switch_stmt, tree val);
     101              : extern edge find_taken_edge_switch_expr (const gswitch *switch_stmt, tree val);
     102              : extern unsigned int execute_fixup_cfg (void);
     103              : extern unsigned int split_critical_edges (bool for_edge_insertion_p = false);
     104              : extern basic_block insert_cond_bb (basic_block, gimple *, gimple *,
     105              :                                    profile_probability);
     106              : extern bool gimple_find_sub_bbs (gimple_seq, gimple_stmt_iterator *);
     107              : extern bool extract_true_false_controlled_edges (basic_block, basic_block,
     108              :                                                  edge *, edge *);
     109              : extern void generate_range_test (basic_block bb, tree index, tree low,
     110              :                                  tree high, tree *lhs, tree *rhs);
     111              : extern basic_block gimple_switch_label_bb (function *, gswitch *, unsigned);
     112              : extern basic_block gimple_switch_default_bb (function *, gswitch *);
     113              : extern edge gimple_switch_edge (function *, gswitch *, unsigned);
     114              : extern edge gimple_switch_default_edge (function *, gswitch *);
     115              : extern bool cond_only_block_p (basic_block);
     116              : extern void copy_phi_arg_into_existing_phi (edge, edge, bool = false);
     117              : extern bool make_forwarders_with_degenerate_phis (function *, bool = false);
     118              : 
     119              : /* Return true if the LHS of a call should be removed.  */
     120              : 
     121              : inline bool
     122    142391187 : should_remove_lhs_p (tree lhs)
     123              : {
     124    142391187 :   return (lhs
     125        15608 :           && TREE_CODE (TYPE_SIZE_UNIT (TREE_TYPE (lhs))) == INTEGER_CST
     126    142406740 :           && !TREE_ADDRESSABLE (TREE_TYPE (lhs)));
     127              : }
     128              : 
     129              : 
     130              : inline unsigned int
     131      3184682 : split_edges_for_insertion ()
     132              : {
     133      3184682 :   return split_critical_edges (/*for_edge_insertion_p=*/true);
     134              : }
     135              : 
     136              : #endif /* _TREE_CFG_H  */