]>
Commit | Line | Data |
---|---|---|
6de9cd9a | 1 | /* Data and Control Flow Analysis for Trees. |
c75c517d | 2 | Copyright (C) 2001, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 |
3d8864c0 | 3 | Free Software Foundation, Inc. |
6de9cd9a DN |
4 | Contributed by Diego Novillo <dnovillo@redhat.com> |
5 | ||
6 | This file is part of GCC. | |
7 | ||
8 | GCC is free software; you can redistribute it and/or modify | |
9 | it under the terms of the GNU General Public License as published by | |
9dcd6f09 | 10 | the Free Software Foundation; either version 3, or (at your option) |
6de9cd9a DN |
11 | any later version. |
12 | ||
13 | GCC is distributed in the hope that it will be useful, | |
14 | but WITHOUT ANY WARRANTY; without even the implied warranty of | |
15 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
16 | GNU General Public License for more details. | |
17 | ||
18 | You should have received a copy of the GNU General Public License | |
9dcd6f09 NC |
19 | along with GCC; see the file COPYING3. If not see |
20 | <http://www.gnu.org/licenses/>. */ | |
6de9cd9a DN |
21 | |
22 | #ifndef _TREE_FLOW_H | |
23 | #define _TREE_FLOW_H 1 | |
24 | ||
25 | #include "bitmap.h" | |
7a8cba34 | 26 | #include "sbitmap.h" |
6de9cd9a DN |
27 | #include "basic-block.h" |
28 | #include "hashtab.h" | |
726a989a | 29 | #include "gimple.h" |
6de9cd9a | 30 | #include "tree-ssa-operands.h" |
6674a6ce | 31 | #include "cgraph.h" |
ea900239 | 32 | #include "ipa-reference.h" |
5006671f | 33 | #include "tree-ssa-alias.h" |
6de9cd9a | 34 | |
e9e0aa2c | 35 | |
2f8e468b KH |
36 | /* Gimple dataflow datastructure. All publicly available fields shall have |
37 | gimple_ accessor defined in tree-flow-inline.h, all publicly modifiable | |
5cd4ec7f | 38 | fields should have gimple_set accessor. */ |
d1b38208 | 39 | struct GTY(()) gimple_df { |
3b302421 RG |
40 | /* Array of all variables referenced in the function. */ |
41 | htab_t GTY((param_is (union tree_node))) referenced_vars; | |
38635499 | 42 | |
726a989a | 43 | /* A vector of all the noreturn calls passed to modify_stmt. |
5cd4ec7f JH |
44 | cleanup_control_flow uses it to detect cases where a mid-block |
45 | indirect call has been turned into a noreturn call. When this | |
46 | happens, all the instructions after the call are no longer | |
47 | reachable and must be deleted as dead. */ | |
726a989a | 48 | VEC(gimple,gc) *modified_noreturn_calls; |
38635499 | 49 | |
5cd4ec7f JH |
50 | /* Array of all SSA_NAMEs used in the function. */ |
51 | VEC(tree,gc) *ssa_names; | |
52 | ||
5006671f RG |
53 | /* Artificial variable used for the virtual operand FUD chain. */ |
54 | tree vop; | |
5cd4ec7f | 55 | |
5006671f RG |
56 | /* The PTA solution for the ESCAPED artificial variable. */ |
57 | struct pt_solution escaped; | |
15c15196 | 58 | |
55b34b5f RG |
59 | /* A map of decls to artificial ssa-names that point to the partition |
60 | of the decl. */ | |
61 | struct pointer_map_t * GTY((skip(""))) decls_to_pointers; | |
62 | ||
5cd4ec7f JH |
63 | /* Free list of SSA_NAMEs. */ |
64 | tree free_ssanames; | |
65 | ||
66 | /* Hashtable holding definition for symbol. If this field is not NULL, it | |
67 | means that the first reference to this variable in the function is a | |
68 | USE or a VUSE. In those cases, the SSA renamer creates an SSA name | |
69 | for this variable with an empty defining statement. */ | |
e445a2ff | 70 | htab_t GTY((param_is (union tree_node))) default_defs; |
5cd4ec7f | 71 | |
5006671f RG |
72 | /* Symbols whose SSA form needs to be updated or created for the first |
73 | time. */ | |
74 | bitmap syms_to_rename; | |
5cd4ec7f JH |
75 | |
76 | /* True if the code is in ssa form. */ | |
77 | unsigned int in_ssa_p : 1; | |
456cde30 | 78 | |
25a6a873 RG |
79 | /* True if IPA points-to information was computed for this function. */ |
80 | unsigned int ipa_pta : 1; | |
81 | ||
456cde30 | 82 | struct ssa_operands ssa_operands; |
5cd4ec7f JH |
83 | }; |
84 | ||
85 | /* Accessors for internal use only. Generic code should use abstraction | |
86 | provided by tree-flow-inline.h or specific modules. */ | |
87 | #define FREE_SSANAMES(fun) (fun)->gimple_df->free_ssanames | |
88 | #define SSANAMES(fun) (fun)->gimple_df->ssa_names | |
89 | #define MODIFIED_NORETURN_CALLS(fun) (fun)->gimple_df->modified_noreturn_calls | |
90 | #define DEFAULT_DEFS(fun) (fun)->gimple_df->default_defs | |
5006671f | 91 | #define SYMS_TO_RENAME(fun) (fun)->gimple_df->syms_to_rename |
9885da8e | 92 | |
a3648cfc DB |
93 | typedef struct |
94 | { | |
95 | htab_t htab; | |
96 | PTR *slot; | |
97 | PTR *limit; | |
98 | } htab_iterator; | |
99 | ||
100 | /* Iterate through the elements of hashtable HTAB, using htab_iterator ITER, | |
101 | storing each element in RESULT, which is of type TYPE. */ | |
102 | #define FOR_EACH_HTAB_ELEMENT(HTAB, RESULT, TYPE, ITER) \ | |
103 | for (RESULT = (TYPE) first_htab_element (&(ITER), (HTAB)); \ | |
104 | !end_htab_p (&(ITER)); \ | |
105 | RESULT = (TYPE) next_htab_element (&(ITER))) | |
106 | ||
ff2ad0f7 DN |
107 | /*--------------------------------------------------------------------------- |
108 | Attributes for SSA_NAMEs. | |
b8698a0f | 109 | |
ff2ad0f7 DN |
110 | NOTE: These structures are stored in struct tree_ssa_name |
111 | but are only used by the tree optimizers, so it makes better sense | |
112 | to declare them here to avoid recompiling unrelated files when | |
113 | making changes. | |
114 | ---------------------------------------------------------------------------*/ | |
115 | ||
116 | /* Aliasing information for SSA_NAMEs representing pointer variables. */ | |
25a6a873 | 117 | |
d1b38208 | 118 | struct GTY(()) ptr_info_def |
ff2ad0f7 | 119 | { |
25a6a873 | 120 | /* The points-to solution. */ |
5006671f | 121 | struct pt_solution pt; |
ff2ad0f7 DN |
122 | }; |
123 | ||
124 | ||
6de9cd9a DN |
125 | /* It is advantageous to avoid things like life analysis for variables which |
126 | do not need PHI nodes. This enum describes whether or not a particular | |
127 | variable may need a PHI node. */ | |
128 | ||
129 | enum need_phi_state { | |
130 | /* This is the default. If we are still in this state after finding | |
131 | all the definition and use sites, then we will assume the variable | |
132 | needs PHI nodes. This is probably an overly conservative assumption. */ | |
133 | NEED_PHI_STATE_UNKNOWN, | |
134 | ||
b8698a0f | 135 | /* This state indicates that we have seen one or more sets of the |
6de9cd9a DN |
136 | variable in a single basic block and that the sets dominate all |
137 | uses seen so far. If after finding all definition and use sites | |
138 | we are still in this state, then the variable does not need any | |
139 | PHI nodes. */ | |
140 | NEED_PHI_STATE_NO, | |
141 | ||
142 | /* This state indicates that we have either seen multiple definitions of | |
143 | the variable in multiple blocks, or that we encountered a use in a | |
144 | block that was not dominated by the block containing the set(s) of | |
145 | this variable. This variable is assumed to need PHI nodes. */ | |
146 | NEED_PHI_STATE_MAYBE | |
147 | }; | |
148 | ||
e9e0aa2c | 149 | |
d1b38208 | 150 | struct GTY(()) var_ann_d { |
7290d709 AM |
151 | /* Used when building base variable structures in a var_map. */ |
152 | unsigned base_var_processed : 1; | |
6de9cd9a | 153 | |
6de9cd9a DN |
154 | /* Nonzero if this variable was used after SSA optimizations were |
155 | applied. We set this when translating out of SSA form. */ | |
156 | unsigned used : 1; | |
157 | ||
158 | /* This field indicates whether or not the variable may need PHI nodes. | |
159 | See the enum's definition for more detailed information about the | |
160 | states. */ | |
161 | ENUM_BITFIELD (need_phi_state) need_phi_state : 2; | |
162 | ||
e9e0aa2c DN |
163 | /* True for HEAP artificial variables. These variables represent |
164 | the memory area allocated by a call to malloc. */ | |
ae536040 ZD |
165 | unsigned is_heapvar : 1; |
166 | ||
7290d709 AM |
167 | /* Used by var_map for the base index of ssa base variables. */ |
168 | unsigned base_index; | |
6de9cd9a | 169 | |
6de9cd9a | 170 | /* During into-ssa and the dominator optimizer, this field holds the |
84d65814 | 171 | current version of this variable (an SSA_NAME). */ |
6de9cd9a DN |
172 | tree current_def; |
173 | }; | |
174 | ||
726a989a RB |
175 | |
176 | /* Immediate use lists are used to directly access all uses for an SSA | |
b8698a0f | 177 | name and get pointers to the statement for each use. |
726a989a RB |
178 | |
179 | The structure ssa_use_operand_d consists of PREV and NEXT pointers | |
180 | to maintain the list. A USE pointer, which points to address where | |
181 | the use is located and a LOC pointer which can point to the | |
182 | statement where the use is located, or, in the case of the root | |
183 | node, it points to the SSA name itself. | |
184 | ||
185 | The list is anchored by an occurrence of ssa_operand_d *in* the | |
186 | ssa_name node itself (named 'imm_uses'). This node is uniquely | |
187 | identified by having a NULL USE pointer. and the LOC pointer | |
188 | pointing back to the ssa_name node itself. This node forms the | |
189 | base for a circular list, and initially this is the only node in | |
190 | the list. | |
191 | ||
192 | Fast iteration allows each use to be examined, but does not allow | |
193 | any modifications to the uses or stmts. | |
194 | ||
195 | Normal iteration allows insertion, deletion, and modification. the | |
196 | iterator manages this by inserting a marker node into the list | |
197 | immediately before the node currently being examined in the list. | |
198 | this marker node is uniquely identified by having null stmt *and* a | |
b8698a0f | 199 | null use pointer. |
726a989a RB |
200 | |
201 | When iterating to the next use, the iteration routines check to see | |
202 | if the node after the marker has changed. if it has, then the node | |
203 | following the marker is now the next one to be visited. if not, the | |
204 | marker node is moved past that node in the list (visualize it as | |
205 | bumping the marker node through the list). this continues until | |
206 | the marker node is moved to the original anchor position. the | |
207 | marker node is then removed from the list. | |
208 | ||
209 | If iteration is halted early, the marker node must be removed from | |
210 | the list before continuing. */ | |
f430bae8 | 211 | typedef struct immediate_use_iterator_d |
6de9cd9a | 212 | { |
6c00f606 | 213 | /* This is the current use the iterator is processing. */ |
f47c96aa | 214 | ssa_use_operand_t *imm_use; |
6c00f606 | 215 | /* This marks the last use in the list (use node from SSA_NAME) */ |
f47c96aa | 216 | ssa_use_operand_t *end_p; |
6c00f606 | 217 | /* This node is inserted and used to mark the end of the uses for a stmt. */ |
f47c96aa | 218 | ssa_use_operand_t iter_node; |
6c00f606 AM |
219 | /* This is the next ssa_name to visit. IMM_USE may get removed before |
220 | the next one is traversed to, so it must be cached early. */ | |
221 | ssa_use_operand_t *next_imm_name; | |
f430bae8 AM |
222 | } imm_use_iterator; |
223 | ||
6de9cd9a | 224 | |
f652d14b | 225 | /* Use this iterator when simply looking at stmts. Adding, deleting or |
f430bae8 AM |
226 | modifying stmts will cause this iterator to malfunction. */ |
227 | ||
60d3aec4 | 228 | #define FOR_EACH_IMM_USE_FAST(DEST, ITER, SSAVAR) \ |
f430bae8 AM |
229 | for ((DEST) = first_readonly_imm_use (&(ITER), (SSAVAR)); \ |
230 | !end_readonly_imm_use_p (&(ITER)); \ | |
60d3aec4 | 231 | (void) ((DEST) = next_readonly_imm_use (&(ITER)))) |
b8698a0f | 232 | |
6c00f606 | 233 | /* Use this iterator to visit each stmt which has a use of SSAVAR. */ |
6de9cd9a | 234 | |
6c00f606 AM |
235 | #define FOR_EACH_IMM_USE_STMT(STMT, ITER, SSAVAR) \ |
236 | for ((STMT) = first_imm_use_stmt (&(ITER), (SSAVAR)); \ | |
237 | !end_imm_use_stmt_p (&(ITER)); \ | |
60d3aec4 | 238 | (void) ((STMT) = next_imm_use_stmt (&(ITER)))) |
f430bae8 | 239 | |
b8698a0f | 240 | /* Use this to terminate the FOR_EACH_IMM_USE_STMT loop early. Failure to |
6c00f606 AM |
241 | do so will result in leaving a iterator marker node in the immediate |
242 | use list, and nothing good will come from that. */ | |
243 | #define BREAK_FROM_IMM_USE_STMT(ITER) \ | |
f430bae8 | 244 | { \ |
6c00f606 | 245 | end_imm_use_stmt_traverse (&(ITER)); \ |
f430bae8 AM |
246 | break; \ |
247 | } | |
6de9cd9a | 248 | |
6c00f606 | 249 | |
b8698a0f | 250 | /* Use this iterator in combination with FOR_EACH_IMM_USE_STMT to |
6fc0bb99 | 251 | get access to each occurrence of ssavar on the stmt returned by |
6c00f606 AM |
252 | that iterator.. for instance: |
253 | ||
254 | FOR_EACH_IMM_USE_STMT (stmt, iter, var) | |
255 | { | |
256 | FOR_EACH_IMM_USE_ON_STMT (use_p, iter) | |
257 | { | |
4b756989 | 258 | SET_USE (use_p, blah); |
6c00f606 AM |
259 | } |
260 | update_stmt (stmt); | |
261 | } */ | |
262 | ||
263 | #define FOR_EACH_IMM_USE_ON_STMT(DEST, ITER) \ | |
264 | for ((DEST) = first_imm_use_on_stmt (&(ITER)); \ | |
265 | !end_imm_use_on_stmt_p (&(ITER)); \ | |
60d3aec4 | 266 | (void) ((DEST) = next_imm_use_on_stmt (&(ITER)))) |
6c00f606 AM |
267 | |
268 | ||
269 | ||
6de9cd9a | 270 | typedef struct var_ann_d *var_ann_t; |
6de9cd9a | 271 | |
9566a759 | 272 | static inline var_ann_t var_ann (const_tree); |
6de9cd9a | 273 | static inline var_ann_t get_var_ann (tree); |
726a989a | 274 | static inline void update_stmt (gimple); |
726a989a | 275 | static inline int get_lineno (const_gimple); |
6de9cd9a DN |
276 | |
277 | /*--------------------------------------------------------------------------- | |
278 | Structure representing predictions in tree level. | |
279 | ---------------------------------------------------------------------------*/ | |
d1b38208 | 280 | struct GTY((chain_next ("%h.ep_next"))) edge_prediction { |
59ced947 RÁE |
281 | struct edge_prediction *ep_next; |
282 | edge ep_edge; | |
283 | enum br_predictor ep_predictor; | |
284 | int ep_probability; | |
6de9cd9a DN |
285 | }; |
286 | ||
6de9cd9a | 287 | /* Accessors for basic block annotations. */ |
726a989a RB |
288 | static inline gimple_seq phi_nodes (const_basic_block); |
289 | static inline void set_phi_nodes (basic_block, gimple_seq); | |
6de9cd9a DN |
290 | |
291 | /*--------------------------------------------------------------------------- | |
292 | Global declarations | |
293 | ---------------------------------------------------------------------------*/ | |
d1b38208 | 294 | struct GTY(()) int_tree_map { |
b8698a0f | 295 | |
a3648cfc DB |
296 | unsigned int uid; |
297 | tree to; | |
298 | }; | |
299 | ||
300 | extern unsigned int int_tree_map_hash (const void *); | |
301 | extern int int_tree_map_eq (const void *, const void *); | |
302 | ||
3b302421 RG |
303 | extern unsigned int uid_decl_map_hash (const void *); |
304 | extern int uid_decl_map_eq (const void *, const void *); | |
305 | ||
b8698a0f | 306 | typedef struct |
a3648cfc | 307 | { |
3b302421 | 308 | htab_iterator hti; |
a3648cfc DB |
309 | } referenced_var_iterator; |
310 | ||
b9d33488 | 311 | /* This macro loops over all the referenced vars, one at a time, putting the |
3b302421 RG |
312 | current var in VAR. Note: You are not allowed to add referenced variables |
313 | to the hashtable while using this macro. Doing so may cause it to behave | |
314 | erratically. */ | |
b9d33488 | 315 | |
a3648cfc | 316 | #define FOR_EACH_REFERENCED_VAR(VAR, ITER) \ |
3b302421 RG |
317 | for ((VAR) = first_referenced_var (&(ITER)); \ |
318 | !end_referenced_vars_p (&(ITER)); \ | |
b8698a0f | 319 | (VAR) = next_referenced_var (&(ITER))) |
a3648cfc | 320 | |
a3648cfc | 321 | extern tree referenced_var_lookup (unsigned int); |
b23987ec | 322 | extern bool referenced_var_check_and_insert (tree); |
3b302421 | 323 | #define num_referenced_vars htab_elements (gimple_referenced_vars (cfun)) |
a3648cfc | 324 | #define referenced_var(i) referenced_var_lookup (i) |
6de9cd9a | 325 | |
5cd4ec7f JH |
326 | #define num_ssa_names (VEC_length (tree, cfun->gimple_df->ssa_names)) |
327 | #define ssa_name(i) (VEC_index (tree, cfun->gimple_df->ssa_names, (i))) | |
6de9cd9a DN |
328 | |
329 | /* Macros for showing usage statistics. */ | |
330 | #define SCALE(x) ((unsigned long) ((x) < 1024*10 \ | |
331 | ? (x) \ | |
332 | : ((x) < 1024*1024*10 \ | |
333 | ? (x) / 1024 \ | |
334 | : (x) / (1024*1024)))) | |
335 | ||
336 | #define LABEL(x) ((x) < 1024*10 ? 'b' : ((x) < 1024*1024*10 ? 'k' : 'M')) | |
337 | ||
338 | #define PERCENT(x,y) ((float)(x) * 100.0 / (float)(y)) | |
339 | ||
777f7f9a RH |
340 | /*--------------------------------------------------------------------------- |
341 | OpenMP Region Tree | |
342 | ---------------------------------------------------------------------------*/ | |
343 | ||
344 | /* Parallel region information. Every parallel and workshare | |
345 | directive is enclosed between two markers, the OMP_* directive | |
346 | and a corresponding OMP_RETURN statement. */ | |
347 | ||
348 | struct omp_region | |
349 | { | |
350 | /* The enclosing region. */ | |
351 | struct omp_region *outer; | |
352 | ||
353 | /* First child region. */ | |
354 | struct omp_region *inner; | |
355 | ||
356 | /* Next peer region. */ | |
357 | struct omp_region *next; | |
358 | ||
359 | /* Block containing the omp directive as its last stmt. */ | |
360 | basic_block entry; | |
361 | ||
362 | /* Block containing the OMP_RETURN as its last stmt. */ | |
363 | basic_block exit; | |
364 | ||
365 | /* Block containing the OMP_CONTINUE as its last stmt. */ | |
366 | basic_block cont; | |
367 | ||
368 | /* If this is a combined parallel+workshare region, this is a list | |
369 | of additional arguments needed by the combined parallel+workshare | |
370 | library call. */ | |
371 | tree ws_args; | |
372 | ||
373 | /* The code for the omp directive of this region. */ | |
726a989a | 374 | enum gimple_code type; |
777f7f9a | 375 | |
21a66e91 JJ |
376 | /* Schedule kind, only used for OMP_FOR type regions. */ |
377 | enum omp_clause_schedule_kind sched_kind; | |
378 | ||
777f7f9a RH |
379 | /* True if this is a combined parallel+workshare region. */ |
380 | bool is_combined_parallel; | |
381 | }; | |
382 | ||
383 | extern struct omp_region *root_omp_region; | |
726a989a | 384 | extern struct omp_region *new_omp_region (basic_block, enum gimple_code, |
777f7f9a RH |
385 | struct omp_region *); |
386 | extern void free_omp_regions (void); | |
5f40b3cb | 387 | void omp_expand_local (basic_block); |
e0c68ce9 | 388 | extern tree find_omp_clause (tree, enum omp_clause_code); |
917948d3 | 389 | tree copy_var_decl (tree, tree, tree); |
777f7f9a | 390 | |
6de9cd9a DN |
391 | /*--------------------------------------------------------------------------- |
392 | Function prototypes | |
393 | ---------------------------------------------------------------------------*/ | |
394 | /* In tree-cfg.c */ | |
395 | ||
396 | /* Location to track pending stmt for edge insertion. */ | |
726a989a | 397 | #define PENDING_STMT(e) ((e)->insns.g) |
6de9cd9a | 398 | |
242229bb | 399 | extern void delete_tree_cfg_annotations (void); |
726a989a RB |
400 | extern bool stmt_ends_bb_p (gimple); |
401 | extern bool is_ctrl_stmt (gimple); | |
402 | extern bool is_ctrl_altering_stmt (gimple); | |
403 | extern bool simple_goto_p (gimple); | |
404 | extern bool stmt_can_make_abnormal_goto (gimple); | |
bc23502b | 405 | extern basic_block single_noncomplex_succ (basic_block bb); |
726a989a RB |
406 | extern void gimple_dump_bb (basic_block, FILE *, int, int); |
407 | extern void gimple_debug_bb (basic_block); | |
408 | extern basic_block gimple_debug_bb_n (int); | |
409 | extern void gimple_dump_cfg (FILE *, int); | |
410 | extern void gimple_debug_cfg (int); | |
6de9cd9a | 411 | extern void dump_cfg_stats (FILE *); |
0c8efed8 | 412 | extern void dot_cfg (void); |
6de9cd9a | 413 | extern void debug_cfg_stats (void); |
0c8efed8 SP |
414 | extern void debug_loops (int); |
415 | extern void debug_loop (struct loop *, int); | |
416 | extern void debug_loop_num (unsigned, int); | |
417 | extern void print_loops (FILE *, int); | |
418 | extern void print_loops_bb (FILE *, basic_block, int, int); | |
165b54c3 SB |
419 | extern void cleanup_dead_labels (void); |
420 | extern void group_case_labels (void); | |
726a989a RB |
421 | extern gimple first_stmt (basic_block); |
422 | extern gimple last_stmt (basic_block); | |
423 | extern gimple last_and_only_stmt (basic_block); | |
6de9cd9a | 424 | extern edge find_taken_edge (basic_block, tree); |
997de8ed SB |
425 | extern basic_block label_to_block_fn (struct function *, tree); |
426 | #define label_to_block(t) (label_to_block_fn (cfun, t)) | |
726a989a | 427 | extern void notice_special_calls (gimple); |
6de9cd9a | 428 | extern void clear_special_calls (void); |
6de9cd9a | 429 | extern void verify_stmts (void); |
7e98624c | 430 | extern void verify_gimple (void); |
726a989a RB |
431 | extern void verify_types_in_gimple_seq (gimple_seq); |
432 | extern tree gimple_block_label (basic_block); | |
6de9cd9a | 433 | extern void extract_true_false_edges_from_block (basic_block, edge *, edge *); |
726a989a | 434 | extern bool gimple_duplicate_sese_region (edge, edge, basic_block *, unsigned, |
42759f1e | 435 | basic_block *); |
726a989a | 436 | extern bool gimple_duplicate_sese_tail (edge, edge, basic_block *, unsigned, |
5f40b3cb | 437 | basic_block *); |
9f9f72aa AP |
438 | extern void gather_blocks_in_sese_region (basic_block entry, basic_block exit, |
439 | VEC(basic_block,heap) **bbs_p); | |
42759f1e | 440 | extern void add_phi_args_after_copy_bb (basic_block); |
5f40b3cb | 441 | extern void add_phi_args_after_copy (basic_block *, unsigned, edge); |
726a989a RB |
442 | extern bool gimple_purge_dead_abnormal_call_edges (basic_block); |
443 | extern bool gimple_purge_dead_eh_edges (basic_block); | |
444 | extern bool gimple_purge_all_dead_eh_edges (const_bitmap); | |
445 | extern tree gimplify_build1 (gimple_stmt_iterator *, enum tree_code, | |
26277d41 | 446 | tree, tree); |
726a989a | 447 | extern tree gimplify_build2 (gimple_stmt_iterator *, enum tree_code, |
26277d41 | 448 | tree, tree, tree); |
726a989a | 449 | extern tree gimplify_build3 (gimple_stmt_iterator *, enum tree_code, |
26277d41 | 450 | tree, tree, tree, tree); |
a930a4ef | 451 | extern void init_empty_tree_cfg (void); |
908ff6a3 | 452 | extern void init_empty_tree_cfg_for_function (struct function *); |
e21aff8a | 453 | extern void fold_cond_expr_cond (void); |
4f6c2131 | 454 | extern void make_abnormal_goto_edges (basic_block, bool); |
684aaf29 | 455 | extern void replace_uses_by (tree, tree); |
c9784e6d KH |
456 | extern void start_recording_case_labels (void); |
457 | extern void end_recording_case_labels (void); | |
50674e96 | 458 | extern basic_block move_sese_region_to_fn (struct function *, basic_block, |
b357f682 | 459 | basic_block, tree); |
672987e8 | 460 | void remove_edge_and_dominated_blocks (edge); |
d7f09764 | 461 | bool tree_node_can_be_shared (tree); |
c9784e6d KH |
462 | |
463 | /* In tree-cfgcleanup.c */ | |
672987e8 | 464 | extern bitmap cfgcleanup_altered_bbs; |
c9784e6d | 465 | extern bool cleanup_tree_cfg (void); |
6de9cd9a DN |
466 | |
467 | /* In tree-pretty-print.c. */ | |
468 | extern void dump_generic_bb (FILE *, basic_block, int, int); | |
0cf0d02b JJ |
469 | extern int op_code_prio (enum tree_code); |
470 | extern int op_prio (const_tree); | |
bbc8a8dc | 471 | extern const char *op_symbol_code (enum tree_code); |
6de9cd9a DN |
472 | |
473 | /* In tree-dfa.c */ | |
474 | extern var_ann_t create_var_ann (tree); | |
908ff6a3 | 475 | extern void renumber_gimple_stmt_uids (void); |
2c08497a | 476 | extern void renumber_gimple_stmt_uids_in_blocks (basic_block *, int); |
6de9cd9a DN |
477 | extern void dump_dfa_stats (FILE *); |
478 | extern void debug_dfa_stats (void); | |
479 | extern void debug_referenced_vars (void); | |
480 | extern void dump_referenced_vars (FILE *); | |
481 | extern void dump_variable (FILE *, tree); | |
482 | extern void debug_variable (tree); | |
6de9cd9a | 483 | extern tree get_virtual_var (tree); |
65401a0b | 484 | extern bool add_referenced_var (tree); |
326648f1 | 485 | extern void remove_referenced_var (tree); |
726a989a RB |
486 | extern void mark_symbols_for_renaming (gimple); |
487 | extern void find_new_referenced_vars (gimple); | |
571325db | 488 | extern tree make_rename_temp (tree, const char *); |
86051306 | 489 | extern void set_default_def (tree, tree); |
5cd4ec7f | 490 | extern tree gimple_default_def (struct function *, tree); |
726a989a | 491 | extern bool stmt_references_abnormal_ssa_name (gimple); |
5006671f RG |
492 | extern tree get_ref_base_and_extent (tree, HOST_WIDE_INT *, |
493 | HOST_WIDE_INT *, HOST_WIDE_INT *); | |
70f34814 | 494 | extern tree get_addr_base_and_unit_offset (tree, HOST_WIDE_INT *); |
07485407 | 495 | extern void find_referenced_vars_in (gimple); |
6de9cd9a | 496 | |
e5e0238e JM |
497 | /* In tree-phinodes.c */ |
498 | extern void reserve_phi_args_for_new_edge (basic_block); | |
f8bf9252 SP |
499 | extern void add_phi_node_to_bb (gimple phi, basic_block bb); |
500 | extern gimple make_phi_node (tree var, int len); | |
726a989a | 501 | extern gimple create_phi_node (tree, basic_block); |
f5045c96 | 502 | extern void add_phi_arg (gimple, tree, edge, source_location); |
e5e0238e | 503 | extern void remove_phi_args (edge); |
726a989a | 504 | extern void remove_phi_node (gimple_stmt_iterator *, bool); |
81b822d5 | 505 | extern void remove_phi_nodes (basic_block); |
5db9ba0c DN |
506 | extern void init_phinodes (void); |
507 | extern void fini_phinodes (void); | |
726a989a | 508 | extern void release_phi_node (gimple); |
5db9ba0c DN |
509 | #ifdef GATHER_STATISTICS |
510 | extern void phinodes_print_statistics (void); | |
511 | #endif | |
e5e0238e | 512 | |
6de9cd9a | 513 | /* In gimple-low.c */ |
50674e96 | 514 | extern void record_vars_into (tree, tree); |
6de9cd9a | 515 | extern void record_vars (tree); |
726a989a RB |
516 | extern bool gimple_seq_may_fallthru (gimple_seq); |
517 | extern bool gimple_stmt_may_fallthru (gimple); | |
6eb29714 | 518 | extern bool gimple_check_call_args (gimple); |
6de9cd9a | 519 | |
ea7e6d5a | 520 | |
6de9cd9a | 521 | /* In tree-ssa.c */ |
ea7e6d5a AH |
522 | |
523 | /* Mapping for redirected edges. */ | |
d1b38208 | 524 | struct GTY(()) _edge_var_map { |
ea7e6d5a AH |
525 | tree result; /* PHI result. */ |
526 | tree def; /* PHI arg definition. */ | |
f5045c96 | 527 | source_location locus; /* PHI arg location. */ |
ea7e6d5a AH |
528 | }; |
529 | typedef struct _edge_var_map edge_var_map; | |
530 | ||
531 | DEF_VEC_O(edge_var_map); | |
532 | DEF_VEC_ALLOC_O(edge_var_map, heap); | |
533 | ||
534 | /* A vector of var maps. */ | |
535 | typedef VEC(edge_var_map, heap) *edge_var_map_vector; | |
536 | ||
908ff6a3 | 537 | extern void init_tree_ssa (struct function *); |
f5045c96 | 538 | extern void redirect_edge_var_map_add (edge, tree, tree, source_location); |
ea7e6d5a AH |
539 | extern void redirect_edge_var_map_clear (edge); |
540 | extern void redirect_edge_var_map_dup (edge, edge); | |
541 | extern edge_var_map_vector redirect_edge_var_map_vector (edge); | |
542 | extern void redirect_edge_var_map_destroy (void); | |
543 | ||
6de9cd9a | 544 | extern edge ssa_redirect_edge (edge, basic_block); |
88957e79 | 545 | extern void flush_pending_stmts (edge); |
f430bae8 | 546 | extern void verify_ssa (bool); |
6de9cd9a | 547 | extern void delete_tree_ssa (void); |
7b7e6ecd | 548 | extern bool ssa_undefined_value_p (tree); |
34f97b94 XDL |
549 | extern void warn_uninit (tree, const char *, void *); |
550 | extern unsigned int warn_uninitialized_vars (bool); | |
5006671f RG |
551 | extern void execute_update_addresses_taken (bool); |
552 | ||
553 | /* Call-back function for walk_use_def_chains(). At each reaching | |
554 | definition, a function with this prototype is called. */ | |
555 | typedef bool (*walk_use_def_chains_fn) (tree, gimple, void *); | |
556 | ||
557 | extern void walk_use_def_chains (tree, walk_use_def_chains_fn, void *, bool); | |
6de9cd9a | 558 | |
0ca5af51 AO |
559 | void insert_debug_temps_for_defs (gimple_stmt_iterator *); |
560 | void insert_debug_temp_for_var_def (gimple_stmt_iterator *, tree); | |
ae0a4449 | 561 | void release_defs_bitset (bitmap toremove); |
ea7e6d5a | 562 | |
6de9cd9a | 563 | /* In tree-into-ssa.c */ |
0bca51f0 | 564 | void update_ssa (unsigned); |
84d65814 | 565 | void delete_update_ssa (void); |
0bca51f0 | 566 | void register_new_name_mapping (tree, tree); |
726a989a | 567 | tree create_new_def_for (tree, gimple, def_operand_p); |
5006671f | 568 | bool need_ssa_update_p (struct function *); |
8f8bb1d2 | 569 | bool name_mappings_registered_p (void); |
0bca51f0 DN |
570 | bool name_registered_for_update_p (tree); |
571 | bitmap ssa_names_to_replace (void); | |
cfaab3a9 | 572 | void release_ssa_name_after_update_ssa (tree); |
5f240ec4 | 573 | void compute_global_livein (bitmap, bitmap); |
0bca51f0 DN |
574 | void mark_sym_for_renaming (tree); |
575 | void mark_set_for_renaming (bitmap); | |
70f34814 | 576 | bool symbol_marked_for_renaming (tree); |
84d65814 DN |
577 | tree get_current_def (tree); |
578 | void set_current_def (tree, tree); | |
6de9cd9a | 579 | |
5db9ba0c DN |
580 | /* In tree-ssanames.c */ |
581 | extern void init_ssanames (struct function *, int); | |
582 | extern void fini_ssanames (void); | |
726a989a RB |
583 | extern tree make_ssa_name_fn (struct function *, tree, gimple); |
584 | extern tree duplicate_ssa_name (tree, gimple); | |
5db9ba0c DN |
585 | extern void duplicate_ssa_name_ptr_info (tree, struct ptr_info_def *); |
586 | extern void release_ssa_name (tree); | |
726a989a | 587 | extern void release_defs (gimple); |
5db9ba0c DN |
588 | extern void replace_ssa_name_symbol (tree, tree); |
589 | ||
590 | #ifdef GATHER_STATISTICS | |
591 | extern void ssanames_print_statistics (void); | |
592 | #endif | |
593 | ||
6de9cd9a | 594 | /* In tree-ssa-ccp.c */ |
ed97ddc6 | 595 | tree fold_const_aggregate_ref (tree); |
6de9cd9a DN |
596 | |
597 | /* In tree-ssa-dom.c */ | |
598 | extern void dump_dominator_optimization_stats (FILE *); | |
599 | extern void debug_dominator_optimization_stats (void); | |
0bca51f0 | 600 | int loop_depth_of_name (tree); |
bf1cbdc6 | 601 | tree degenerate_phi_result (gimple); |
6de9cd9a DN |
602 | |
603 | /* In tree-ssa-copy.c */ | |
d00ad49b AM |
604 | extern void propagate_value (use_operand_p, tree); |
605 | extern void propagate_tree_value (tree *, tree); | |
726a989a | 606 | extern void propagate_tree_value_into_stmt (gimple_stmt_iterator *, tree); |
d00ad49b | 607 | extern void replace_exp (use_operand_p, tree); |
63b88252 | 608 | extern bool may_propagate_copy (tree, tree); |
726a989a | 609 | extern bool may_propagate_copy_into_stmt (gimple, tree); |
aa24864c | 610 | extern bool may_propagate_copy_into_asm (tree); |
6de9cd9a | 611 | |
17684618 ZD |
612 | /* Affine iv. */ |
613 | ||
614 | typedef struct | |
615 | { | |
616 | /* Iv = BASE + STEP * i. */ | |
617 | tree base, step; | |
618 | ||
619 | /* True if this iv does not overflow. */ | |
620 | bool no_overflow; | |
621 | } affine_iv; | |
622 | ||
e9eb809d ZD |
623 | /* Description of number of iterations of a loop. All the expressions inside |
624 | the structure can be evaluated at the end of the loop's preheader | |
625 | (and due to ssa form, also anywhere inside the body of the loop). */ | |
626 | ||
627 | struct tree_niter_desc | |
628 | { | |
6cb38cd4 | 629 | tree assumptions; /* The boolean expression. If this expression evaluates |
e9eb809d ZD |
630 | to false, then the other fields in this structure |
631 | should not be used; there is no guarantee that they | |
632 | will be correct. */ | |
2a7e31df | 633 | tree may_be_zero; /* The boolean expression. If it evaluates to true, |
e9eb809d ZD |
634 | the loop will exit in the first iteration (i.e. |
635 | its latch will not be executed), even if the niter | |
636 | field says otherwise. */ | |
637 | tree niter; /* The expression giving the number of iterations of | |
638 | a loop (provided that assumptions == true and | |
639 | may_be_zero == false), more precisely the number | |
640 | of executions of the latch of the loop. */ | |
b3ce5b6e ZD |
641 | double_int max; /* The upper bound on the number of iterations of |
642 | the loop. */ | |
17684618 ZD |
643 | |
644 | /* The simplified shape of the exit condition. The loop exits if | |
645 | CONTROL CMP BOUND is false, where CMP is one of NE_EXPR, | |
646 | LT_EXPR, or GT_EXPR, and step of CONTROL is positive if CMP is | |
647 | LE_EXPR and negative if CMP is GE_EXPR. This information is used | |
648 | by loop unrolling. */ | |
649 | affine_iv control; | |
650 | tree bound; | |
651 | enum tree_code cmp; | |
e9eb809d ZD |
652 | }; |
653 | ||
79fe1b3b | 654 | /* In tree-ssa-phiopt.c */ |
b48d0358 | 655 | bool empty_block_p (basic_block); |
18d08014 | 656 | basic_block *blocks_in_phiopt_order (void); |
79fe1b3b | 657 | |
e9eb809d ZD |
658 | /* In tree-ssa-loop*.c */ |
659 | ||
e3bdfed6 | 660 | unsigned int tree_ssa_lim (void); |
d73be268 ZD |
661 | unsigned int tree_ssa_unswitch_loops (void); |
662 | unsigned int canonicalize_induction_variables (void); | |
d6e840ee | 663 | unsigned int tree_unroll_loops_completely (bool, bool); |
d73be268 | 664 | unsigned int tree_ssa_prefetch_arrays (void); |
d73be268 | 665 | void tree_ssa_iv_optimize (void); |
592c303d | 666 | unsigned tree_predictive_commoning (void); |
c80a5403 | 667 | tree canonicalize_loop_ivs (struct loop *, tree *, bool); |
5f40b3cb | 668 | bool parallelize_loops (void); |
a7e5372d | 669 | |
52778e2a | 670 | bool loop_only_exit_p (const struct loop *, const_edge); |
e9eb809d | 671 | bool number_of_iterations_exit (struct loop *, edge, |
f9cc1a70 | 672 | struct tree_niter_desc *niter, bool); |
ca4c3169 | 673 | tree find_loop_niter (struct loop *, edge *); |
e9eb809d ZD |
674 | tree loop_niter_by_eval (struct loop *, edge); |
675 | tree find_loop_niter_by_eval (struct loop *, edge *); | |
d73be268 | 676 | void estimate_numbers_of_iterations (void); |
3899a0b2 | 677 | bool array_at_struct_end_p (tree); |
726a989a RB |
678 | bool scev_probably_wraps_p (tree, tree, gimple, struct loop *, bool); |
679 | bool convert_affine_scev (struct loop *, tree, tree *, tree *, gimple, bool); | |
d7f5de76 ZD |
680 | |
681 | bool nowrap_type_p (tree); | |
682 | enum ev_direction {EV_DIR_GROWS, EV_DIR_DECREASES, EV_DIR_UNKNOWN}; | |
ed7a4b4b | 683 | enum ev_direction scev_direction (const_tree); |
d7f5de76 | 684 | |
d73be268 | 685 | void free_numbers_of_iterations_estimates (void); |
c9639aae | 686 | void free_numbers_of_iterations_estimates_loop (struct loop *); |
84d65814 | 687 | void rewrite_into_loop_closed_ssa (bitmap, unsigned); |
a3b9e73c | 688 | void verify_loop_closed_ssa (bool); |
a7e5372d | 689 | bool for_each_index (tree *, bool (*) (tree, tree *, void *), void *); |
726a989a | 690 | void create_iv (tree, tree, tree, struct loop *, gimple_stmt_iterator *, bool, |
82b85a85 | 691 | tree *, tree *); |
5f40b3cb | 692 | basic_block split_loop_exit_edge (edge); |
726a989a | 693 | void standard_iv_increment_position (struct loop *, gimple_stmt_iterator *, |
8b11a64c ZD |
694 | bool *); |
695 | basic_block ip_end_pos (struct loop *); | |
696 | basic_block ip_normal_pos (struct loop *); | |
726a989a | 697 | bool gimple_duplicate_loop_to_header_edge (struct loop *, edge, |
92fc4a2f | 698 | unsigned int, sbitmap, |
ee8c1b05 ZD |
699 | edge, VEC (edge, heap) **, |
700 | int); | |
dea61d92 SP |
701 | struct loop *slpeel_tree_duplicate_loop_to_edge_cfg (struct loop *, edge); |
702 | void rename_variables_in_loop (struct loop *); | |
f8bf9252 | 703 | void rename_variables_in_bb (basic_block bb); |
d73be268 | 704 | struct loop *tree_ssa_loop_version (struct loop *, tree, |
92fc4a2f | 705 | basic_block *); |
d7bf3bcf | 706 | tree expand_simple_operations (tree); |
d5ab5675 | 707 | void substitute_in_loop_info (struct loop *, tree, tree); |
b7eae7b8 | 708 | edge single_dom_exit (struct loop *); |
17684618 ZD |
709 | bool can_unroll_loop_p (struct loop *loop, unsigned factor, |
710 | struct tree_niter_desc *niter); | |
d73be268 | 711 | void tree_unroll_loop (struct loop *, unsigned, |
17684618 | 712 | edge, struct tree_niter_desc *); |
567b96ed ZD |
713 | typedef void (*transform_callback)(struct loop *, void *); |
714 | void tree_transform_and_unroll_loop (struct loop *, unsigned, | |
715 | edge, struct tree_niter_desc *, | |
716 | transform_callback, void *); | |
e5db3515 | 717 | bool contains_abnormal_ssa_name_p (tree); |
726a989a RB |
718 | bool stmt_dominates_stmt_p (gimple, gimple); |
719 | void mark_virtual_ops_for_renaming (gimple); | |
e9eb809d | 720 | |
1d65f45c RH |
721 | /* In tree-ssa-dce.c */ |
722 | void mark_virtual_phi_result_for_renaming (gimple); | |
723 | ||
2090d6a0 | 724 | /* In tree-ssa-threadedge.c */ |
448ee662 RG |
725 | extern void threadedge_initialize_values (void); |
726 | extern void threadedge_finalize_values (void); | |
727 | extern VEC(tree,heap) *ssa_name_values; | |
728 | #define SSA_NAME_VALUE(x) \ | |
729 | (SSA_NAME_VERSION(x) < VEC_length(tree, ssa_name_values) \ | |
730 | ? VEC_index(tree, ssa_name_values, SSA_NAME_VERSION(x)) \ | |
731 | : NULL_TREE) | |
732 | extern void set_ssa_name_value (tree, tree); | |
2090d6a0 | 733 | extern bool potentially_threadable_block (basic_block); |
726a989a RB |
734 | extern void thread_across_edge (gimple, edge, bool, |
735 | VEC(tree, heap) **, tree (*) (gimple, gimple)); | |
2090d6a0 | 736 | |
40923b20 DP |
737 | /* In tree-ssa-loop-im.c */ |
738 | /* The possibilities of statement movement. */ | |
739 | ||
740 | enum move_pos | |
741 | { | |
742 | MOVE_IMPOSSIBLE, /* No movement -- side effect expression. */ | |
743 | MOVE_PRESERVE_EXECUTION, /* Must not cause the non-executed statement | |
744 | become executed -- memory accesses, ... */ | |
745 | MOVE_POSSIBLE /* Unlimited movement. */ | |
746 | }; | |
726a989a | 747 | extern enum move_pos movement_possibility (gimple); |
bbc8a8dc | 748 | char *get_lsm_tmp_name (tree, unsigned); |
d16a5e36 | 749 | |
6de9cd9a | 750 | /* In tree-flow-inline.h */ |
727a31fa | 751 | static inline void set_is_used (tree); |
9566a759 | 752 | static inline bool unmodifiable_var_p (const_tree); |
5006671f | 753 | static inline bool ref_contains_array_ref (const_tree); |
6de9cd9a DN |
754 | |
755 | /* In tree-eh.c */ | |
726a989a | 756 | extern void make_eh_edges (gimple); |
1d65f45c RH |
757 | extern bool make_eh_dispatch_edges (gimple); |
758 | extern edge redirect_eh_edge (edge, basic_block); | |
759 | extern void redirect_eh_dispatch_edge (gimple, edge, basic_block); | |
6de9cd9a | 760 | extern bool tree_could_trap_p (tree); |
890065bf RG |
761 | extern bool operation_could_trap_helper_p (enum tree_code, bool, bool, bool, |
762 | bool, tree, bool *); | |
726a989a RB |
763 | extern bool operation_could_trap_p (enum tree_code, bool, bool, tree); |
764 | extern bool stmt_could_throw_p (gimple); | |
6de9cd9a | 765 | extern bool tree_could_throw_p (tree); |
726a989a | 766 | extern bool stmt_can_throw_internal (gimple); |
33977f81 | 767 | extern bool stmt_can_throw_external (gimple); |
1d65f45c RH |
768 | extern void add_stmt_to_eh_lp_fn (struct function *, gimple, int); |
769 | extern void add_stmt_to_eh_lp (gimple, int); | |
770 | extern bool remove_stmt_from_eh_lp (gimple); | |
771 | extern bool remove_stmt_from_eh_lp_fn (struct function *, gimple); | |
772 | extern int lookup_stmt_eh_lp_fn (struct function *, gimple); | |
1d65f45c RH |
773 | extern int lookup_stmt_eh_lp (gimple); |
774 | extern bool maybe_clean_eh_stmt_fn (struct function *, gimple); | |
775 | extern bool maybe_clean_eh_stmt (gimple); | |
726a989a | 776 | extern bool maybe_clean_or_replace_eh_stmt (gimple, gimple); |
1d65f45c RH |
777 | extern bool maybe_duplicate_eh_stmt_fn (struct function *, gimple, |
778 | struct function *, gimple, | |
779 | struct pointer_map_t *, int); | |
780 | extern bool maybe_duplicate_eh_stmt (gimple, gimple); | |
726a989a | 781 | extern bool verify_eh_edges (gimple); |
1d65f45c | 782 | extern bool verify_eh_dispatch_edge (gimple); |
6de9cd9a | 783 | |
33c94679 | 784 | /* In tree-ssa-pre.c */ |
c9145754 DB |
785 | struct pre_expr_d; |
786 | void add_to_value (unsigned int, struct pre_expr_d *); | |
787 | void debug_value_expressions (unsigned int); | |
788 | void print_value_expressions (FILE *, unsigned int); | |
b71b4522 | 789 | |
fa555252 | 790 | /* In tree-ssa-sink.c */ |
726a989a | 791 | bool is_hidden_global_store (gimple); |
33c94679 | 792 | |
599eabdb | 793 | /* In tree-loop-linear.c */ |
d73be268 | 794 | extern void linear_transform_loops (void); |
f8bf9252 SP |
795 | extern unsigned perfect_loop_nest_depth (struct loop *); |
796 | ||
797 | /* In graphite.c */ | |
798 | extern void graphite_transform_loops (void); | |
599eabdb | 799 | |
3d8864c0 SP |
800 | /* In tree-data-ref.c */ |
801 | extern void tree_check_data_deps (void); | |
802 | ||
feb075f4 | 803 | /* In tree-ssa-loop-ivopts.c */ |
ac182688 | 804 | bool expr_invariant_in_loop_p (struct loop *, tree); |
726a989a | 805 | bool stmt_invariant_in_loop_p (struct loop *, gimple); |
09e881c9 BE |
806 | bool multiplier_allowed_in_address_p (HOST_WIDE_INT, enum machine_mode, |
807 | addr_space_t); | |
f40751dd | 808 | unsigned multiply_by_cost (HOST_WIDE_INT, enum machine_mode, bool); |
8b11a64c | 809 | |
4aab792d | 810 | /* In tree-ssa-threadupdate.c. */ |
b02b9b53 | 811 | extern bool thread_through_all_blocks (bool); |
8702a557 | 812 | extern void register_jump_thread (edge, edge); |
4aab792d | 813 | |
9885da8e | 814 | /* In gimplify.c */ |
726a989a RB |
815 | tree force_gimple_operand (tree, gimple_seq *, bool, tree); |
816 | tree force_gimple_operand_gsi (gimple_stmt_iterator *, tree, bool, tree, | |
817 | bool, enum gsi_iterator_update); | |
de4af523 | 818 | tree gimple_fold_indirect_ref (tree); |
8b11a64c | 819 | |
3f519b35 RG |
820 | /* In tree-ssa-live.c */ |
821 | extern void remove_unused_locals (void); | |
cff7525f | 822 | extern void dump_scope_blocks (FILE *, int); |
ac80ba07 | 823 | extern void debug_scope_blocks (int); |
c6a21142 | 824 | extern void debug_scope_block (tree, int); |
3f519b35 | 825 | |
ac182688 ZD |
826 | /* In tree-ssa-address.c */ |
827 | ||
ac182688 ZD |
828 | /* Description of a memory address. */ |
829 | ||
830 | struct mem_address | |
831 | { | |
832 | tree symbol, base, index, step, offset; | |
833 | }; | |
834 | ||
73f30c63 | 835 | struct affine_tree_combination; |
b8698a0f | 836 | tree create_mem_ref (gimple_stmt_iterator *, tree, |
d7c0c068 | 837 | struct affine_tree_combination *, tree, bool); |
d4ebfa65 | 838 | rtx addr_for_mem_ref (struct mem_address *, addr_space_t, bool); |
ac182688 ZD |
839 | void get_address_description (tree, struct mem_address *); |
840 | tree maybe_fold_tmr (tree); | |
50674e96 | 841 | |
4e3825db | 842 | unsigned int execute_free_datastructures (void); |
873aa8f5 | 843 | unsigned int execute_fixup_cfg (void); |
566d09ef | 844 | bool fixup_noreturn_call (gimple stmt); |
c900f6aa | 845 | |
7ea6b6cf JH |
846 | /* In ipa-pure-const.c */ |
847 | void warn_function_noreturn (tree); | |
848 | ||
6de9cd9a DN |
849 | #include "tree-flow-inline.h" |
850 | ||
726a989a | 851 | void swap_tree_operands (gimple, tree *, tree *); |
0e0ed594 | 852 | |
911b3fdb ZD |
853 | int least_common_multiple (int, int); |
854 | ||
6de9cd9a | 855 | #endif /* _TREE_FLOW_H */ |