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