1/* Hooks for cfg representation specific functions.
2   Copyright (C) 2003, 2004, 2005 Free Software Foundation, Inc.
3   Contributed by Sebastian Pop <s.pop@laposte.net>
4
5This file is part of GCC.
6
7GCC is free software; you can redistribute it and/or modify
8it under the terms of the GNU General Public License as published by
9the Free Software Foundation; either version 2, or (at your option)
10any later version.
11
12GCC is distributed in the hope that it will be useful,
13but WITHOUT ANY WARRANTY; without even the implied warranty of
14MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15GNU General Public License for more details.
16
17You should have received a copy of the GNU General Public License
18along with GCC; see the file COPYING.  If not, write to
19the Free Software Foundation, 51 Franklin Street, Fifth Floor,
20Boston, MA 02110-1301, USA.  */
21
22#ifndef GCC_CFGHOOKS_H
23#define GCC_CFGHOOKS_H
24
25struct cfg_hooks
26{
27  /* Name of the corresponding ir.  */
28  const char *name;
29
30  /* Debugging.  */
31  int (*verify_flow_info) (void);
32  void (*dump_bb) (basic_block, FILE *, int);
33
34  /* Basic CFG manipulation.  */
35
36  /* Return new basic block.  */
37  basic_block (*create_basic_block) (void *head, void *end, basic_block after);
38
39  /* Redirect edge E to the given basic block B and update underlying program
40     representation.  Returns edge representing redirected branch (that may not
41     be equivalent to E in the case of duplicate edges being removed) or NULL
42     if edge is not easily redirectable for whatever reason.  */
43  edge (*redirect_edge_and_branch) (edge e, basic_block b);
44
45  /* Same as the above but allows redirecting of fallthru edges.  In that case
46     newly created forwarder basic block is returned.  The edge must
47     not be abnormal.  */
48  basic_block (*redirect_edge_and_branch_force) (edge, basic_block);
49
50  /* Remove statements corresponding to a given basic block.  */
51  void (*delete_basic_block) (basic_block);
52
53  /* Creates a new basic block just after basic block B by splitting
54     everything after specified instruction I.  */
55  basic_block (*split_block) (basic_block b, void * i);
56
57  /* Move block B immediately after block A.  */
58  bool (*move_block_after) (basic_block b, basic_block a);
59
60  /* Return true when blocks A and B can be merged into single basic block.  */
61  bool (*can_merge_blocks_p) (basic_block a, basic_block b);
62
63  /* Merge blocks A and B.  */
64  void (*merge_blocks) (basic_block a, basic_block b);
65
66  /* Predict edge E using PREDICTOR to given PROBABILITY.  */
67  void (*predict_edge) (edge e, enum br_predictor predictor, int probability);
68
69  /* Return true if the one of outgoing edges is already predicted by
70     PREDICTOR.  */
71  bool (*predicted_by_p) (basic_block bb, enum br_predictor predictor);
72
73  /* Return true when block A can be duplicated.  */
74  bool (*can_duplicate_block_p) (basic_block a);
75
76  /* Duplicate block A.  */
77  basic_block (*duplicate_block) (basic_block a);
78
79  /* Higher level functions representable by primitive operations above if
80     we didn't have some oddities in RTL and Tree representations.  */
81  basic_block (*split_edge) (edge);
82  void (*make_forwarder_block) (edge);
83
84  /* Tries to make the edge fallthru.  */
85  void (*tidy_fallthru_edge) (edge);
86
87  /* Say whether a block ends with a call, possibly followed by some
88     other code that must stay with the call.  */
89  bool (*block_ends_with_call_p) (basic_block);
90
91  /* Say whether a block ends with a conditional branch.  Switches
92     and unconditional branches do not qualify.  */
93  bool (*block_ends_with_condjump_p) (basic_block);
94
95  /* Add fake edges to the function exit for any non constant and non noreturn
96     calls, volatile inline assembly in the bitmap of blocks specified by
97     BLOCKS or to the whole CFG if BLOCKS is zero.  Return the number of blocks
98     that were split.
99
100     The goal is to expose cases in which entering a basic block does not imply
101     that all subsequent instructions must be executed.  */
102  int (*flow_call_edges_add) (sbitmap);
103
104  /* This function is called immediately after edge E is added to the
105     edge vector E->dest->preds.  */
106  void (*execute_on_growing_pred) (edge);
107
108  /* This function is called immediately before edge E is removed from
109     the edge vector E->dest->preds.  */
110  void (*execute_on_shrinking_pred) (edge);
111
112  /* A hook for duplicating loop in CFG, currently this is used
113     in loop versioning.  */
114  bool (*cfg_hook_duplicate_loop_to_header_edge) (struct loop *loop, edge e,
115						  struct loops *loops,
116						  unsigned int ndupl,
117						  sbitmap wont_exit,
118						  edge orig, edge *to_remove,
119						  unsigned int *n_to_remove,
120						  int flags);
121
122  /* Add condition to new basic block and update CFG used in loop
123     versioning.  */
124  void (*lv_add_condition_to_bb) (basic_block, basic_block, basic_block,
125  				  void *);
126  /* Update the PHI nodes in case of loop versioning.  */
127  void (*lv_adjust_loop_header_phi) (basic_block, basic_block,
128				     basic_block, edge);
129
130  /* Given a condition BB extract the true/false taken/not taken edges
131     (depending if we are on tree's or RTL). */
132  void (*extract_cond_bb_edges) (basic_block, edge *, edge *);
133
134
135  /* Add PHI arguments queued in PENDINT_STMT list on edge E to edge
136     E->dest (only in tree-ssa loop versioning.  */
137  void (*flush_pending_stmts) (edge);
138};
139
140extern void verify_flow_info (void);
141extern void dump_bb (basic_block, FILE *, int);
142extern edge redirect_edge_and_branch (edge, basic_block);
143extern basic_block redirect_edge_and_branch_force (edge, basic_block);
144extern edge split_block (basic_block, void *);
145extern edge split_block_after_labels (basic_block);
146extern bool move_block_after (basic_block, basic_block);
147extern void delete_basic_block (basic_block);
148extern basic_block split_edge (edge);
149extern basic_block create_basic_block (void *, void *, basic_block);
150extern basic_block create_empty_bb (basic_block);
151extern bool can_merge_blocks_p (basic_block, basic_block);
152extern void merge_blocks (basic_block, basic_block);
153extern edge make_forwarder_block (basic_block, bool (*)(edge),
154				  void (*) (basic_block));
155extern void tidy_fallthru_edge (edge);
156extern void tidy_fallthru_edges (void);
157extern void predict_edge (edge e, enum br_predictor predictor, int probability);
158extern bool predicted_by_p (basic_block bb, enum br_predictor predictor);
159extern bool can_duplicate_block_p (basic_block);
160extern basic_block duplicate_block (basic_block, edge, basic_block);
161extern bool block_ends_with_call_p (basic_block bb);
162extern bool block_ends_with_condjump_p (basic_block bb);
163extern int flow_call_edges_add (sbitmap);
164extern void execute_on_growing_pred (edge);
165extern void execute_on_shrinking_pred (edge);
166extern bool cfg_hook_duplicate_loop_to_header_edge (struct loop *loop, edge,
167						    struct loops *loops,
168						    unsigned int ndupl,
169						    sbitmap wont_exit,
170						    edge orig, edge *to_remove,
171						    unsigned int *n_to_remove,
172						    int flags);
173
174extern void lv_flush_pending_stmts (edge);
175extern void extract_cond_bb_edges (basic_block, edge *, edge*);
176extern void lv_adjust_loop_header_phi (basic_block, basic_block, basic_block,
177				       edge);
178extern void lv_add_condition_to_bb (basic_block, basic_block, basic_block,
179				    void *);
180
181/* Hooks containers.  */
182extern struct cfg_hooks tree_cfg_hooks;
183extern struct cfg_hooks rtl_cfg_hooks;
184extern struct cfg_hooks cfg_layout_rtl_cfg_hooks;
185
186/* Declarations.  */
187extern int ir_type (void);
188extern void rtl_register_cfg_hooks (void);
189extern void cfg_layout_rtl_register_cfg_hooks (void);
190extern void tree_register_cfg_hooks (void);
191
192#endif  /* GCC_CFGHOOKS_H */
193