]>
Commit | Line | Data |
---|---|---|
6de9cd9a | 1 | /* Data and Control Flow Analysis for Trees. |
3d8864c0 SP |
2 | Copyright (C) 2001, 2003, 2004, 2005, 2006, 2007 |
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" | |
eadf906f | 29 | #include "tree-gimple.h" |
6de9cd9a | 30 | #include "tree-ssa-operands.h" |
6674a6ce | 31 | #include "cgraph.h" |
ea900239 | 32 | #include "ipa-reference.h" |
6de9cd9a DN |
33 | |
34 | /* Forward declare structures for the garbage collector GTY markers. */ | |
35 | #ifndef GCC_BASIC_BLOCK_H | |
36 | struct edge_def; | |
37 | typedef struct edge_def *edge; | |
38 | struct basic_block_def; | |
39 | typedef struct basic_block_def *basic_block; | |
40 | #endif | |
adb6509f | 41 | struct static_var_ann_d; |
6de9cd9a | 42 | |
e9e0aa2c DN |
43 | /* Memory reference statistics for individual memory symbols, |
44 | collected during alias analysis. */ | |
45 | struct mem_sym_stats_d GTY(()) | |
46 | { | |
47 | /* Memory symbol. */ | |
48 | tree var; | |
49 | ||
50 | /* Nonzero if this entry has been assigned a partition. */ | |
51 | unsigned int partitioned_p : 1; | |
52 | ||
53 | /* Nonzero if VAR is a memory partition tag that already contains | |
54 | call-clobbered variables in its partition set. */ | |
55 | unsigned int has_call_clobbered_vars : 1; | |
56 | ||
57 | /* Number of direct reference sites. A direct reference to VAR is any | |
58 | reference of the form 'VAR = ' or ' = VAR'. For GIMPLE reg | |
59 | pointers, this is the number of sites where the pointer is | |
60 | dereferenced. */ | |
61 | long num_direct_writes; | |
62 | long num_direct_reads; | |
63 | ||
64 | /* Number of indirect reference sites. An indirect reference to VAR | |
65 | is any reference via a pointer that contains VAR in its points-to | |
66 | set or, in the case of call-clobbered symbols, a function call. */ | |
67 | long num_indirect_writes; | |
68 | long num_indirect_reads; | |
69 | ||
70 | /* Execution frequency. This is the sum of the execution | |
71 | frequencies of all the statements that reference this object | |
72 | weighted by the number of references in each statement. This is | |
73 | the main key used to sort the list of symbols to partition. | |
74 | Symbols with high execution frequencies are put at the bottom of | |
75 | the work list (ie, they are partitioned last). | |
76 | Execution frequencies are taken directly from each basic block, | |
77 | so compiling with PGO enabled will increase the precision of this | |
78 | estimate. */ | |
79 | long frequency_reads; | |
80 | long frequency_writes; | |
81 | ||
82 | /* Set of memory tags that contain VAR in their alias set. */ | |
83 | bitmap parent_tags; | |
84 | }; | |
85 | ||
86 | typedef struct mem_sym_stats_d *mem_sym_stats_t; | |
87 | DEF_VEC_P(mem_sym_stats_t); | |
88 | DEF_VEC_ALLOC_P(mem_sym_stats_t, heap); | |
89 | ||
90 | /* Memory reference statistics collected during alias analysis. */ | |
91 | struct mem_ref_stats_d GTY(()) | |
92 | { | |
93 | /* Number of statements that make memory references. */ | |
94 | long num_mem_stmts; | |
95 | ||
96 | /* Number of statements that make function calls. */ | |
97 | long num_call_sites; | |
98 | ||
99 | /* Number of statements that make calls to pure/const functions. */ | |
100 | long num_pure_const_call_sites; | |
101 | ||
102 | /* Number of ASM statements. */ | |
103 | long num_asm_sites; | |
104 | ||
105 | /* Estimated number of virtual operands needed as computed by | |
106 | compute_memory_partitions. */ | |
107 | long num_vuses; | |
108 | long num_vdefs; | |
109 | ||
110 | /* This maps every symbol used to make "memory" references | |
111 | (pointers, arrays, structures, etc) to an instance of struct | |
112 | mem_sym_stats_d describing reference statistics for the symbol. */ | |
113 | struct pointer_map_t * GTY((skip)) mem_sym_stats; | |
114 | }; | |
115 | ||
116 | ||
2f8e468b KH |
117 | /* Gimple dataflow datastructure. All publicly available fields shall have |
118 | gimple_ accessor defined in tree-flow-inline.h, all publicly modifiable | |
5cd4ec7f | 119 | fields should have gimple_set accessor. */ |
e9e0aa2c DN |
120 | struct gimple_df GTY(()) |
121 | { | |
5cd4ec7f JH |
122 | /* Array of all variables referenced in the function. */ |
123 | htab_t GTY((param_is (struct int_tree_map))) referenced_vars; | |
38635499 | 124 | |
5cd4ec7f JH |
125 | /* A list of all the noreturn calls passed to modify_stmt. |
126 | cleanup_control_flow uses it to detect cases where a mid-block | |
127 | indirect call has been turned into a noreturn call. When this | |
128 | happens, all the instructions after the call are no longer | |
129 | reachable and must be deleted as dead. */ | |
130 | VEC(tree,gc) *modified_noreturn_calls; | |
38635499 | 131 | |
5cd4ec7f JH |
132 | /* Array of all SSA_NAMEs used in the function. */ |
133 | VEC(tree,gc) *ssa_names; | |
134 | ||
135 | /* Artificial variable used to model the effects of function calls. */ | |
136 | tree global_var; | |
137 | ||
138 | /* Artificial variable used to model the effects of nonlocal | |
139 | variables. */ | |
140 | tree nonlocal_all; | |
141 | ||
142 | /* Call clobbered variables in the function. If bit I is set, then | |
143 | REFERENCED_VARS (I) is call-clobbered. */ | |
144 | bitmap call_clobbered_vars; | |
145 | ||
146 | /* Addressable variables in the function. If bit I is set, then | |
147 | REFERENCED_VARS (I) has had its address taken. Note that | |
148 | CALL_CLOBBERED_VARS and ADDRESSABLE_VARS are not related. An | |
149 | addressable variable is not necessarily call-clobbered (e.g., a | |
150 | local addressable whose address does not escape) and not all | |
151 | call-clobbered variables are addressable (e.g., a local static | |
152 | variable). */ | |
153 | bitmap addressable_vars; | |
154 | ||
155 | /* Free list of SSA_NAMEs. */ | |
156 | tree free_ssanames; | |
157 | ||
158 | /* Hashtable holding definition for symbol. If this field is not NULL, it | |
159 | means that the first reference to this variable in the function is a | |
160 | USE or a VUSE. In those cases, the SSA renamer creates an SSA name | |
161 | for this variable with an empty defining statement. */ | |
162 | htab_t GTY((param_is (struct int_tree_map))) default_defs; | |
163 | ||
164 | /* 'true' after aliases have been computed (see compute_may_aliases). */ | |
165 | unsigned int aliases_computed_p : 1; | |
166 | ||
167 | /* True if the code is in ssa form. */ | |
168 | unsigned int in_ssa_p : 1; | |
456cde30 JH |
169 | |
170 | struct ssa_operands ssa_operands; | |
adb6509f JH |
171 | |
172 | /* Hashtable of variables annotations. Used for static variables only; | |
173 | local variables have direct pointer in the tree node. */ | |
174 | htab_t GTY((param_is (struct static_var_ann_d))) var_anns; | |
e9e0aa2c DN |
175 | |
176 | /* Memory reference statistics collected during alias analysis. | |
177 | This information is used to drive the memory partitioning | |
178 | heuristics in compute_memory_partitions. */ | |
179 | struct mem_ref_stats_d mem_ref_stats; | |
5cd4ec7f JH |
180 | }; |
181 | ||
182 | /* Accessors for internal use only. Generic code should use abstraction | |
183 | provided by tree-flow-inline.h or specific modules. */ | |
184 | #define FREE_SSANAMES(fun) (fun)->gimple_df->free_ssanames | |
185 | #define SSANAMES(fun) (fun)->gimple_df->ssa_names | |
186 | #define MODIFIED_NORETURN_CALLS(fun) (fun)->gimple_df->modified_noreturn_calls | |
187 | #define DEFAULT_DEFS(fun) (fun)->gimple_df->default_defs | |
9885da8e | 188 | |
a3648cfc DB |
189 | typedef struct |
190 | { | |
191 | htab_t htab; | |
192 | PTR *slot; | |
193 | PTR *limit; | |
194 | } htab_iterator; | |
195 | ||
196 | /* Iterate through the elements of hashtable HTAB, using htab_iterator ITER, | |
197 | storing each element in RESULT, which is of type TYPE. */ | |
198 | #define FOR_EACH_HTAB_ELEMENT(HTAB, RESULT, TYPE, ITER) \ | |
199 | for (RESULT = (TYPE) first_htab_element (&(ITER), (HTAB)); \ | |
200 | !end_htab_p (&(ITER)); \ | |
201 | RESULT = (TYPE) next_htab_element (&(ITER))) | |
202 | ||
ff2ad0f7 DN |
203 | /*--------------------------------------------------------------------------- |
204 | Attributes for SSA_NAMEs. | |
205 | ||
206 | NOTE: These structures are stored in struct tree_ssa_name | |
207 | but are only used by the tree optimizers, so it makes better sense | |
208 | to declare them here to avoid recompiling unrelated files when | |
209 | making changes. | |
210 | ---------------------------------------------------------------------------*/ | |
211 | ||
212 | /* Aliasing information for SSA_NAMEs representing pointer variables. */ | |
213 | struct ptr_info_def GTY(()) | |
214 | { | |
215 | /* Nonzero if points-to analysis couldn't determine where this pointer | |
216 | is pointing to. */ | |
217 | unsigned int pt_anything : 1; | |
218 | ||
ff2ad0f7 DN |
219 | /* Nonzero if the value of this pointer escapes the current function. */ |
220 | unsigned int value_escapes_p : 1; | |
221 | ||
d8903b30 DN |
222 | /* Nonzero if this pointer is dereferenced. */ |
223 | unsigned int is_dereferenced : 1; | |
224 | ||
50dc9a88 DN |
225 | /* Nonzero if this pointer points to a global variable. */ |
226 | unsigned int pt_global_mem : 1; | |
227 | ||
a1d13fa1 DN |
228 | /* Nonzero if this pointer points to NULL. */ |
229 | unsigned int pt_null : 1; | |
230 | ||
ff2ad0f7 DN |
231 | /* Set of variables that this pointer may point to. */ |
232 | bitmap pt_vars; | |
233 | ||
234 | /* If this pointer has been dereferenced, and points-to information is | |
235 | more precise than type-based aliasing, indirect references to this | |
236 | pointer will be represented by this memory tag, instead of the type | |
237 | tag computed by TBAA. */ | |
238 | tree name_mem_tag; | |
d16a5e36 DB |
239 | |
240 | /* Mask of reasons this pointer's value escapes the function */ | |
241 | unsigned int escape_mask; | |
ff2ad0f7 DN |
242 | }; |
243 | ||
244 | ||
6de9cd9a | 245 | /*--------------------------------------------------------------------------- |
07beea0d | 246 | Tree annotations stored in tree_base.ann |
6de9cd9a | 247 | ---------------------------------------------------------------------------*/ |
3bfdb124 | 248 | enum tree_ann_type { TREE_ANN_COMMON, VAR_ANN, FUNCTION_ANN, STMT_ANN }; |
6de9cd9a DN |
249 | |
250 | struct tree_ann_common_d GTY(()) | |
251 | { | |
252 | /* Annotation type. */ | |
253 | enum tree_ann_type type; | |
7e6eb623 | 254 | |
88088c03 DN |
255 | /* Auxiliary info specific to a pass. At all times, this |
256 | should either point to valid data or be NULL. */ | |
257 | PTR GTY ((skip (""))) aux; | |
258 | ||
7e6eb623 DB |
259 | /* The value handle for this expression. Used by GVN-PRE. */ |
260 | tree GTY((skip)) value_handle; | |
6de9cd9a DN |
261 | }; |
262 | ||
263 | /* It is advantageous to avoid things like life analysis for variables which | |
264 | do not need PHI nodes. This enum describes whether or not a particular | |
265 | variable may need a PHI node. */ | |
266 | ||
267 | enum need_phi_state { | |
268 | /* This is the default. If we are still in this state after finding | |
269 | all the definition and use sites, then we will assume the variable | |
270 | needs PHI nodes. This is probably an overly conservative assumption. */ | |
271 | NEED_PHI_STATE_UNKNOWN, | |
272 | ||
273 | /* This state indicates that we have seen one or more sets of the | |
274 | variable in a single basic block and that the sets dominate all | |
275 | uses seen so far. If after finding all definition and use sites | |
276 | we are still in this state, then the variable does not need any | |
277 | PHI nodes. */ | |
278 | NEED_PHI_STATE_NO, | |
279 | ||
280 | /* This state indicates that we have either seen multiple definitions of | |
281 | the variable in multiple blocks, or that we encountered a use in a | |
282 | block that was not dominated by the block containing the set(s) of | |
283 | this variable. This variable is assumed to need PHI nodes. */ | |
284 | NEED_PHI_STATE_MAYBE | |
285 | }; | |
286 | ||
e9e0aa2c DN |
287 | |
288 | /* The "no alias" attribute allows alias analysis to make more | |
289 | aggressive assumptions when assigning alias sets, computing | |
290 | points-to information and memory partitions. These attributes | |
291 | are the result of user annotations or flags (e.g., | |
292 | -fargument-noalias). */ | |
293 | enum noalias_state { | |
294 | /* Default state. No special assumptions can be made about this | |
295 | symbol. */ | |
296 | MAY_ALIAS = 0, | |
297 | ||
298 | /* The symbol does not alias with other symbols that have a | |
299 | NO_ALIAS* attribute. */ | |
300 | NO_ALIAS, | |
301 | ||
302 | /* The symbol does not alias with other symbols that have a | |
303 | NO_ALIAS*, and it may not alias with global symbols. */ | |
304 | NO_ALIAS_GLOBAL, | |
305 | ||
306 | /* The symbol does not alias with any other symbols. */ | |
307 | NO_ALIAS_ANYTHING | |
308 | }; | |
309 | ||
310 | ||
c75ab022 DB |
311 | struct subvar; |
312 | typedef struct subvar *subvar_t; | |
313 | ||
314 | /* This structure represents a fake sub-variable for a structure field. */ | |
c75ab022 DB |
315 | struct subvar GTY(()) |
316 | { | |
e8ca4159 | 317 | /* Fake variable. */ |
c75ab022 | 318 | tree var; |
e8ca4159 | 319 | |
c75ab022 DB |
320 | /* Next subvar for this structure. */ |
321 | subvar_t next; | |
6de9cd9a DN |
322 | }; |
323 | ||
324 | struct var_ann_d GTY(()) | |
325 | { | |
326 | struct tree_ann_common_d common; | |
327 | ||
6de9cd9a DN |
328 | /* Used by the out of SSA pass to determine whether this variable has |
329 | been seen yet or not. */ | |
330 | unsigned out_of_ssa_tag : 1; | |
331 | ||
7290d709 AM |
332 | /* Used when building base variable structures in a var_map. */ |
333 | unsigned base_var_processed : 1; | |
6de9cd9a | 334 | |
6de9cd9a DN |
335 | /* Nonzero if this variable was used after SSA optimizations were |
336 | applied. We set this when translating out of SSA form. */ | |
337 | unsigned used : 1; | |
338 | ||
339 | /* This field indicates whether or not the variable may need PHI nodes. | |
340 | See the enum's definition for more detailed information about the | |
341 | states. */ | |
342 | ENUM_BITFIELD (need_phi_state) need_phi_state : 2; | |
343 | ||
e288e2f5 | 344 | /* Used during operand processing to determine if this variable is already |
38635499 | 345 | in the VUSE list. */ |
e288e2f5 AM |
346 | unsigned in_vuse_list : 1; |
347 | ||
348 | /* Used during operand processing to determine if this variable is already | |
38635499 DN |
349 | in the VDEF list. */ |
350 | unsigned in_vdef_list : 1; | |
e288e2f5 | 351 | |
e9e0aa2c DN |
352 | /* True for HEAP artificial variables. These variables represent |
353 | the memory area allocated by a call to malloc. */ | |
ae536040 ZD |
354 | unsigned is_heapvar : 1; |
355 | ||
b730fa61 JH |
356 | /* True if the variable is call clobbered. */ |
357 | unsigned int call_clobbered : 1; | |
358 | ||
e9e0aa2c DN |
359 | /* This field describes several "no alias" attributes that some |
360 | symbols are known to have. See the enum's definition for more | |
361 | information on each attribute. */ | |
362 | ENUM_BITFIELD (noalias_state) noalias_state : 2; | |
363 | ||
38635499 DN |
364 | /* Memory partition tag assigned to this symbol. */ |
365 | tree mpt; | |
366 | ||
367 | /* If this variable is a pointer P that has been dereferenced, this | |
368 | field is an artificial variable that represents the memory | |
369 | location *P. Every other pointer Q that is type-compatible with | |
370 | P will also have the same memory tag. If the variable is not a | |
371 | pointer or if it is never dereferenced, this must be NULL. | |
372 | FIXME, do we really need this here? How much slower would it be | |
373 | to convert to hash table? */ | |
18cd8a03 | 374 | tree symbol_mem_tag; |
6de9cd9a | 375 | |
6de9cd9a DN |
376 | /* Used when going out of SSA form to indicate which partition this |
377 | variable represents storage for. */ | |
378 | unsigned partition; | |
379 | ||
7290d709 AM |
380 | /* Used by var_map for the base index of ssa base variables. */ |
381 | unsigned base_index; | |
6de9cd9a | 382 | |
6de9cd9a | 383 | /* During into-ssa and the dominator optimizer, this field holds the |
84d65814 | 384 | current version of this variable (an SSA_NAME). */ |
6de9cd9a | 385 | tree current_def; |
5cd4ec7f | 386 | |
84d65814 DN |
387 | /* If this variable is a structure, this fields holds a list of |
388 | symbols representing each of the fields of the structure. */ | |
c75ab022 | 389 | subvar_t subvars; |
d16a5e36 DB |
390 | |
391 | /* Mask of values saying the reasons why this variable has escaped | |
392 | the function. */ | |
393 | unsigned int escape_mask; | |
6de9cd9a DN |
394 | }; |
395 | ||
2e226e66 | 396 | /* Container for variable annotation used by hashtable for annotations for |
adb6509f JH |
397 | static variables. */ |
398 | struct static_var_ann_d GTY(()) | |
399 | { | |
400 | struct var_ann_d ann; | |
401 | unsigned int uid; | |
402 | }; | |
403 | ||
3bfdb124 DB |
404 | struct function_ann_d GTY(()) |
405 | { | |
406 | struct tree_ann_common_d common; | |
407 | ||
408 | /* Pointer to the structure that contains the sets of global | |
409 | variables modified by function calls. This field is only used | |
410 | for FUNCTION_DECLs. */ | |
411 | ipa_reference_vars_info_t GTY ((skip)) reference_vars_info; | |
412 | }; | |
6de9cd9a | 413 | |
f430bae8 | 414 | typedef struct immediate_use_iterator_d |
6de9cd9a | 415 | { |
6c00f606 | 416 | /* This is the current use the iterator is processing. */ |
f47c96aa | 417 | ssa_use_operand_t *imm_use; |
6c00f606 | 418 | /* This marks the last use in the list (use node from SSA_NAME) */ |
f47c96aa | 419 | ssa_use_operand_t *end_p; |
6c00f606 | 420 | /* This node is inserted and used to mark the end of the uses for a stmt. */ |
f47c96aa | 421 | ssa_use_operand_t iter_node; |
6c00f606 AM |
422 | /* This is the next ssa_name to visit. IMM_USE may get removed before |
423 | the next one is traversed to, so it must be cached early. */ | |
424 | ssa_use_operand_t *next_imm_name; | |
f430bae8 AM |
425 | } imm_use_iterator; |
426 | ||
6de9cd9a | 427 | |
f652d14b | 428 | /* Use this iterator when simply looking at stmts. Adding, deleting or |
f430bae8 AM |
429 | modifying stmts will cause this iterator to malfunction. */ |
430 | ||
431 | #define FOR_EACH_IMM_USE_FAST(DEST, ITER, SSAVAR) \ | |
432 | for ((DEST) = first_readonly_imm_use (&(ITER), (SSAVAR)); \ | |
433 | !end_readonly_imm_use_p (&(ITER)); \ | |
434 | (DEST) = next_readonly_imm_use (&(ITER))) | |
435 | ||
6c00f606 | 436 | /* Use this iterator to visit each stmt which has a use of SSAVAR. */ |
6de9cd9a | 437 | |
6c00f606 AM |
438 | #define FOR_EACH_IMM_USE_STMT(STMT, ITER, SSAVAR) \ |
439 | for ((STMT) = first_imm_use_stmt (&(ITER), (SSAVAR)); \ | |
440 | !end_imm_use_stmt_p (&(ITER)); \ | |
441 | (STMT) = next_imm_use_stmt (&(ITER))) | |
f430bae8 | 442 | |
6c00f606 AM |
443 | /* Use this to terminate the FOR_EACH_IMM_USE_STMT loop early. Failure to |
444 | do so will result in leaving a iterator marker node in the immediate | |
445 | use list, and nothing good will come from that. */ | |
446 | #define BREAK_FROM_IMM_USE_STMT(ITER) \ | |
f430bae8 | 447 | { \ |
6c00f606 | 448 | end_imm_use_stmt_traverse (&(ITER)); \ |
f430bae8 AM |
449 | break; \ |
450 | } | |
6de9cd9a | 451 | |
6c00f606 AM |
452 | |
453 | /* Use this iterator in combination with FOR_EACH_IMM_USE_STMT to | |
6fc0bb99 | 454 | get access to each occurrence of ssavar on the stmt returned by |
6c00f606 AM |
455 | that iterator.. for instance: |
456 | ||
457 | FOR_EACH_IMM_USE_STMT (stmt, iter, var) | |
458 | { | |
459 | FOR_EACH_IMM_USE_ON_STMT (use_p, iter) | |
460 | { | |
461 | SET_USE (use_p) = blah; | |
462 | } | |
463 | update_stmt (stmt); | |
464 | } */ | |
465 | ||
466 | #define FOR_EACH_IMM_USE_ON_STMT(DEST, ITER) \ | |
467 | for ((DEST) = first_imm_use_on_stmt (&(ITER)); \ | |
468 | !end_imm_use_on_stmt_p (&(ITER)); \ | |
469 | (DEST) = next_imm_use_on_stmt (&(ITER))) | |
470 | ||
471 | ||
472 | ||
6de9cd9a DN |
473 | struct stmt_ann_d GTY(()) |
474 | { | |
475 | struct tree_ann_common_d common; | |
476 | ||
6de9cd9a | 477 | /* Basic block that contains this statement. */ |
52f6de6c | 478 | basic_block bb; |
6de9cd9a | 479 | |
f430bae8 | 480 | /* Operand cache for stmt. */ |
f47c96aa | 481 | struct stmt_operands_d GTY ((skip (""))) operands; |
6de9cd9a | 482 | |
6de9cd9a DN |
483 | /* Set of variables that have had their address taken in the statement. */ |
484 | bitmap addresses_taken; | |
485 | ||
486 | /* Unique identifier for this statement. These ID's are to be created | |
487 | by each pass on an as-needed basis in any order convenient for the | |
488 | pass which needs statement UIDs. */ | |
489 | unsigned int uid; | |
1f1e8527 | 490 | |
d48a05c3 JH |
491 | /* Nonzero if the statement references memory (at least one of its |
492 | expressions contains a non-register operand). */ | |
493 | unsigned references_memory : 1; | |
494 | ||
6946b3f7 JH |
495 | /* Nonzero if the statement has been modified (meaning that the operands |
496 | need to be scanned again). */ | |
497 | unsigned modified : 1; | |
498 | ||
499 | /* Nonzero if the statement makes references to volatile storage. */ | |
500 | unsigned has_volatile_ops : 1; | |
501 | ||
502 | /* Nonzero if the statement makes a function call that may clobber global | |
503 | and local addressable variables. */ | |
504 | unsigned makes_clobbering_call : 1; | |
6de9cd9a DN |
505 | }; |
506 | ||
06d72ee6 | 507 | union tree_ann_d GTY((desc ("ann_type ((tree_ann_t)&%h)"))) |
6de9cd9a DN |
508 | { |
509 | struct tree_ann_common_d GTY((tag ("TREE_ANN_COMMON"))) common; | |
3bfdb124 DB |
510 | struct var_ann_d GTY((tag ("VAR_ANN"))) vdecl; |
511 | struct function_ann_d GTY((tag ("FUNCTION_ANN"))) fdecl; | |
6de9cd9a | 512 | struct stmt_ann_d GTY((tag ("STMT_ANN"))) stmt; |
6de9cd9a DN |
513 | }; |
514 | ||
06d72ee6 | 515 | typedef union tree_ann_d *tree_ann_t; |
6de9cd9a | 516 | typedef struct var_ann_d *var_ann_t; |
3bfdb124 | 517 | typedef struct function_ann_d *function_ann_t; |
6de9cd9a | 518 | typedef struct stmt_ann_d *stmt_ann_t; |
93c094b5 | 519 | typedef struct tree_ann_common_d *tree_ann_common_t; |
6de9cd9a | 520 | |
9566a759 | 521 | static inline tree_ann_common_t tree_common_ann (const_tree); |
93c094b5 | 522 | static inline tree_ann_common_t get_tree_common_ann (tree); |
9566a759 | 523 | static inline var_ann_t var_ann (const_tree); |
6de9cd9a | 524 | static inline var_ann_t get_var_ann (tree); |
9566a759 | 525 | static inline function_ann_t function_ann (const_tree); |
3bfdb124 | 526 | static inline function_ann_t get_function_ann (tree); |
6de9cd9a | 527 | static inline stmt_ann_t stmt_ann (tree); |
83737db2 | 528 | static inline bool has_stmt_ann (tree); |
6de9cd9a | 529 | static inline stmt_ann_t get_stmt_ann (tree); |
06d72ee6 | 530 | static inline enum tree_ann_type ann_type (tree_ann_t); |
6de9cd9a DN |
531 | static inline basic_block bb_for_stmt (tree); |
532 | extern void set_bb_for_stmt (tree, basic_block); | |
7ded35b4 | 533 | static inline bool noreturn_call_p (tree); |
f430bae8 | 534 | static inline void update_stmt (tree); |
6de9cd9a | 535 | static inline bool stmt_modified_p (tree); |
9566a759 | 536 | static inline bitmap may_aliases (const_tree); |
6de9cd9a | 537 | static inline int get_lineno (tree); |
6de9cd9a | 538 | static inline bitmap addresses_taken (tree); |
6de9cd9a DN |
539 | |
540 | /*--------------------------------------------------------------------------- | |
541 | Structure representing predictions in tree level. | |
542 | ---------------------------------------------------------------------------*/ | |
59ced947 | 543 | struct edge_prediction GTY((chain_next ("%h.ep_next"))) |
6de9cd9a | 544 | { |
59ced947 RÁE |
545 | struct edge_prediction *ep_next; |
546 | edge ep_edge; | |
547 | enum br_predictor ep_predictor; | |
548 | int ep_probability; | |
6de9cd9a DN |
549 | }; |
550 | ||
6de9cd9a | 551 | /* Accessors for basic block annotations. */ |
6de9cd9a DN |
552 | static inline tree phi_nodes (basic_block); |
553 | static inline void set_phi_nodes (basic_block, tree); | |
554 | ||
555 | /*--------------------------------------------------------------------------- | |
556 | Global declarations | |
557 | ---------------------------------------------------------------------------*/ | |
a3648cfc DB |
558 | struct int_tree_map GTY(()) |
559 | { | |
560 | ||
561 | unsigned int uid; | |
562 | tree to; | |
563 | }; | |
564 | ||
565 | extern unsigned int int_tree_map_hash (const void *); | |
566 | extern int int_tree_map_eq (const void *, const void *); | |
567 | ||
568 | typedef struct | |
569 | { | |
570 | htab_iterator hti; | |
571 | } referenced_var_iterator; | |
572 | ||
573 | ||
b9d33488 DB |
574 | /* This macro loops over all the referenced vars, one at a time, putting the |
575 | current var in VAR. Note: You are not allowed to add referenced variables | |
576 | to the hashtable while using this macro. Doing so may cause it to behave | |
577 | erratically. */ | |
578 | ||
a3648cfc DB |
579 | #define FOR_EACH_REFERENCED_VAR(VAR, ITER) \ |
580 | for ((VAR) = first_referenced_var (&(ITER)); \ | |
581 | !end_referenced_vars_p (&(ITER)); \ | |
582 | (VAR) = next_referenced_var (&(ITER))) | |
583 | ||
b9d33488 DB |
584 | |
585 | typedef struct | |
586 | { | |
587 | int i; | |
588 | } safe_referenced_var_iterator; | |
589 | ||
590 | /* This macro loops over all the referenced vars, one at a time, putting the | |
591 | current var in VAR. You are allowed to add referenced variables during the | |
592 | execution of this macro, however, the macro will not iterate over them. It | |
593 | requires a temporary vector of trees, VEC, whose lifetime is controlled by | |
594 | the caller. The purpose of the vector is to temporarily store the | |
595 | referenced_variables hashtable so that adding referenced variables does not | |
596 | affect the hashtable. */ | |
597 | ||
598 | #define FOR_EACH_REFERENCED_VAR_SAFE(VAR, VEC, ITER) \ | |
599 | for ((ITER).i = 0, fill_referenced_var_vec (&(VEC)); \ | |
600 | VEC_iterate (tree, (VEC), (ITER).i, (VAR)); \ | |
601 | (ITER).i++) | |
602 | ||
a3648cfc | 603 | extern tree referenced_var_lookup (unsigned int); |
b23987ec | 604 | extern bool referenced_var_check_and_insert (tree); |
5cd4ec7f | 605 | #define num_referenced_vars htab_elements (gimple_referenced_vars (cfun)) |
a3648cfc | 606 | #define referenced_var(i) referenced_var_lookup (i) |
6de9cd9a | 607 | |
5cd4ec7f JH |
608 | #define num_ssa_names (VEC_length (tree, cfun->gimple_df->ssa_names)) |
609 | #define ssa_name(i) (VEC_index (tree, cfun->gimple_df->ssa_names, (i))) | |
6de9cd9a DN |
610 | |
611 | /* Macros for showing usage statistics. */ | |
612 | #define SCALE(x) ((unsigned long) ((x) < 1024*10 \ | |
613 | ? (x) \ | |
614 | : ((x) < 1024*1024*10 \ | |
615 | ? (x) / 1024 \ | |
616 | : (x) / (1024*1024)))) | |
617 | ||
618 | #define LABEL(x) ((x) < 1024*10 ? 'b' : ((x) < 1024*1024*10 ? 'k' : 'M')) | |
619 | ||
620 | #define PERCENT(x,y) ((float)(x) * 100.0 / (float)(y)) | |
621 | ||
6de9cd9a DN |
622 | /*--------------------------------------------------------------------------- |
623 | Block iterators | |
624 | ---------------------------------------------------------------------------*/ | |
625 | ||
626 | typedef struct { | |
627 | tree_stmt_iterator tsi; | |
628 | basic_block bb; | |
629 | } block_stmt_iterator; | |
630 | ||
631 | static inline block_stmt_iterator bsi_start (basic_block); | |
632 | static inline block_stmt_iterator bsi_last (basic_block); | |
d7621d3c | 633 | static inline block_stmt_iterator bsi_after_labels (basic_block); |
1a1804c2 | 634 | block_stmt_iterator bsi_for_stmt (tree); |
6de9cd9a DN |
635 | static inline bool bsi_end_p (block_stmt_iterator); |
636 | static inline void bsi_next (block_stmt_iterator *); | |
637 | static inline void bsi_prev (block_stmt_iterator *); | |
638 | static inline tree bsi_stmt (block_stmt_iterator); | |
639 | static inline tree * bsi_stmt_ptr (block_stmt_iterator); | |
640 | ||
736432ee | 641 | extern void bsi_remove (block_stmt_iterator *, bool); |
6de9cd9a DN |
642 | extern void bsi_move_before (block_stmt_iterator *, block_stmt_iterator *); |
643 | extern void bsi_move_after (block_stmt_iterator *, block_stmt_iterator *); | |
644 | extern void bsi_move_to_bb_end (block_stmt_iterator *, basic_block); | |
645 | ||
646 | enum bsi_iterator_update | |
647 | { | |
648 | /* Note that these are intentionally in the same order as TSI_FOO. They | |
649 | mean exactly the same as their TSI_* counterparts. */ | |
650 | BSI_NEW_STMT, | |
651 | BSI_SAME_STMT, | |
652 | BSI_CHAIN_START, | |
653 | BSI_CHAIN_END, | |
654 | BSI_CONTINUE_LINKING | |
655 | }; | |
656 | ||
657 | extern void bsi_insert_before (block_stmt_iterator *, tree, | |
658 | enum bsi_iterator_update); | |
659 | extern void bsi_insert_after (block_stmt_iterator *, tree, | |
660 | enum bsi_iterator_update); | |
661 | ||
662 | extern void bsi_replace (const block_stmt_iterator *, tree, bool); | |
663 | ||
777f7f9a RH |
664 | /*--------------------------------------------------------------------------- |
665 | OpenMP Region Tree | |
666 | ---------------------------------------------------------------------------*/ | |
667 | ||
668 | /* Parallel region information. Every parallel and workshare | |
669 | directive is enclosed between two markers, the OMP_* directive | |
670 | and a corresponding OMP_RETURN statement. */ | |
671 | ||
672 | struct omp_region | |
673 | { | |
674 | /* The enclosing region. */ | |
675 | struct omp_region *outer; | |
676 | ||
677 | /* First child region. */ | |
678 | struct omp_region *inner; | |
679 | ||
680 | /* Next peer region. */ | |
681 | struct omp_region *next; | |
682 | ||
683 | /* Block containing the omp directive as its last stmt. */ | |
684 | basic_block entry; | |
685 | ||
686 | /* Block containing the OMP_RETURN as its last stmt. */ | |
687 | basic_block exit; | |
688 | ||
689 | /* Block containing the OMP_CONTINUE as its last stmt. */ | |
690 | basic_block cont; | |
691 | ||
692 | /* If this is a combined parallel+workshare region, this is a list | |
693 | of additional arguments needed by the combined parallel+workshare | |
694 | library call. */ | |
695 | tree ws_args; | |
696 | ||
697 | /* The code for the omp directive of this region. */ | |
698 | enum tree_code type; | |
699 | ||
21a66e91 JJ |
700 | /* Schedule kind, only used for OMP_FOR type regions. */ |
701 | enum omp_clause_schedule_kind sched_kind; | |
702 | ||
777f7f9a RH |
703 | /* True if this is a combined parallel+workshare region. */ |
704 | bool is_combined_parallel; | |
705 | }; | |
706 | ||
707 | extern struct omp_region *root_omp_region; | |
708 | extern struct omp_region *new_omp_region (basic_block, enum tree_code, | |
709 | struct omp_region *); | |
710 | extern void free_omp_regions (void); | |
711 | ||
6de9cd9a DN |
712 | /*--------------------------------------------------------------------------- |
713 | Function prototypes | |
714 | ---------------------------------------------------------------------------*/ | |
715 | /* In tree-cfg.c */ | |
716 | ||
717 | /* Location to track pending stmt for edge insertion. */ | |
718 | #define PENDING_STMT(e) ((e)->insns.t) | |
719 | ||
242229bb | 720 | extern void delete_tree_cfg_annotations (void); |
6de9cd9a | 721 | extern bool stmt_ends_bb_p (tree); |
6ea2b70d | 722 | extern bool is_ctrl_stmt (const_tree); |
6de9cd9a | 723 | extern bool is_ctrl_altering_stmt (tree); |
6ea2b70d KG |
724 | extern bool computed_goto_p (const_tree); |
725 | extern bool simple_goto_p (const_tree); | |
726 | extern bool tree_can_make_abnormal_goto (const_tree); | |
bc23502b | 727 | extern basic_block single_noncomplex_succ (basic_block bb); |
6de9cd9a DN |
728 | extern void tree_dump_bb (basic_block, FILE *, int); |
729 | extern void debug_tree_bb (basic_block); | |
730 | extern basic_block debug_tree_bb_n (int); | |
731 | extern void dump_tree_cfg (FILE *, int); | |
732 | extern void debug_tree_cfg (int); | |
733 | extern void dump_cfg_stats (FILE *); | |
734 | extern void debug_cfg_stats (void); | |
735 | extern void debug_loop_ir (void); | |
736 | extern void print_loop_ir (FILE *); | |
165b54c3 SB |
737 | extern void cleanup_dead_labels (void); |
738 | extern void group_case_labels (void); | |
6de9cd9a DN |
739 | extern tree first_stmt (basic_block); |
740 | extern tree last_stmt (basic_block); | |
6de9cd9a DN |
741 | extern tree last_and_only_stmt (basic_block); |
742 | extern edge find_taken_edge (basic_block, tree); | |
997de8ed SB |
743 | extern basic_block label_to_block_fn (struct function *, tree); |
744 | #define label_to_block(t) (label_to_block_fn (cfun, t)) | |
6de9cd9a | 745 | extern void bsi_insert_on_edge (edge, tree); |
82b85a85 | 746 | extern basic_block bsi_insert_on_edge_immediate (edge, tree); |
88957e79 | 747 | extern void bsi_commit_one_edge_insert (edge, basic_block *); |
8e731e4e | 748 | extern void bsi_commit_edge_inserts (void); |
6de9cd9a DN |
749 | extern void notice_special_calls (tree); |
750 | extern void clear_special_calls (void); | |
6de9cd9a | 751 | extern void verify_stmts (void); |
7e98624c RG |
752 | extern void verify_gimple (void); |
753 | extern void verify_gimple_1 (tree); | |
88957e79 | 754 | extern tree tree_block_label (basic_block); |
6de9cd9a | 755 | extern void extract_true_false_edges_from_block (basic_block, edge *, edge *); |
42759f1e ZD |
756 | extern bool tree_duplicate_sese_region (edge, edge, basic_block *, unsigned, |
757 | basic_block *); | |
758 | extern void add_phi_args_after_copy_bb (basic_block); | |
759 | extern void add_phi_args_after_copy (basic_block *, unsigned); | |
4f6c2131 | 760 | extern bool tree_purge_dead_abnormal_call_edges (basic_block); |
1eaba2f2 | 761 | extern bool tree_purge_dead_eh_edges (basic_block); |
6ea2b70d | 762 | extern bool tree_purge_all_dead_eh_edges (const_bitmap); |
26277d41 PB |
763 | extern tree gimplify_val (block_stmt_iterator *, tree, tree); |
764 | extern tree gimplify_build1 (block_stmt_iterator *, enum tree_code, | |
765 | tree, tree); | |
766 | extern tree gimplify_build2 (block_stmt_iterator *, enum tree_code, | |
767 | tree, tree, tree); | |
768 | extern tree gimplify_build3 (block_stmt_iterator *, enum tree_code, | |
769 | tree, tree, tree, tree); | |
a930a4ef | 770 | extern void init_empty_tree_cfg (void); |
e21aff8a | 771 | extern void fold_cond_expr_cond (void); |
4f6c2131 | 772 | extern void make_abnormal_goto_edges (basic_block, bool); |
684aaf29 | 773 | extern void replace_uses_by (tree, tree); |
c9784e6d KH |
774 | extern void start_recording_case_labels (void); |
775 | extern void end_recording_case_labels (void); | |
50674e96 DN |
776 | extern basic_block move_sese_region_to_fn (struct function *, basic_block, |
777 | basic_block); | |
672987e8 | 778 | void remove_edge_and_dominated_blocks (edge); |
c9784e6d KH |
779 | |
780 | /* In tree-cfgcleanup.c */ | |
672987e8 | 781 | extern bitmap cfgcleanup_altered_bbs; |
c9784e6d | 782 | extern bool cleanup_tree_cfg (void); |
6de9cd9a DN |
783 | |
784 | /* In tree-pretty-print.c. */ | |
785 | extern void dump_generic_bb (FILE *, basic_block, int, int); | |
bbc8a8dc | 786 | extern const char *op_symbol_code (enum tree_code); |
6de9cd9a DN |
787 | |
788 | /* In tree-dfa.c */ | |
789 | extern var_ann_t create_var_ann (tree); | |
3bfdb124 | 790 | extern function_ann_t create_function_ann (tree); |
6de9cd9a | 791 | extern stmt_ann_t create_stmt_ann (tree); |
93c094b5 | 792 | extern tree_ann_common_t create_tree_common_ann (tree); |
6de9cd9a DN |
793 | extern void dump_dfa_stats (FILE *); |
794 | extern void debug_dfa_stats (void); | |
795 | extern void debug_referenced_vars (void); | |
796 | extern void dump_referenced_vars (FILE *); | |
797 | extern void dump_variable (FILE *, tree); | |
798 | extern void debug_variable (tree); | |
e8ca4159 DN |
799 | extern void dump_subvars_for (FILE *, tree); |
800 | extern void debug_subvars_for (tree); | |
6de9cd9a | 801 | extern tree get_virtual_var (tree); |
f004ab02 | 802 | extern void add_referenced_var (tree); |
326648f1 | 803 | extern void remove_referenced_var (tree); |
cfaab3a9 | 804 | extern void mark_symbols_for_renaming (tree); |
b28b1600 | 805 | extern void find_new_referenced_vars (tree *); |
571325db | 806 | extern tree make_rename_temp (tree, const char *); |
86051306 | 807 | extern void set_default_def (tree, tree); |
5cd4ec7f | 808 | extern tree gimple_default_def (struct function *, tree); |
e9e0aa2c | 809 | extern struct mem_sym_stats_d *mem_sym_stats (struct function *, tree); |
6de9cd9a | 810 | |
e5e0238e JM |
811 | /* In tree-phinodes.c */ |
812 | extern void reserve_phi_args_for_new_edge (basic_block); | |
813 | extern tree create_phi_node (tree, basic_block); | |
814 | extern void add_phi_arg (tree, tree, edge); | |
815 | extern void remove_phi_args (edge); | |
9b3b55a1 | 816 | extern void remove_phi_node (tree, tree, bool); |
e5e0238e JM |
817 | extern tree phi_reverse (tree); |
818 | ||
6de9cd9a | 819 | /* In gimple-low.c */ |
50674e96 | 820 | extern void record_vars_into (tree, tree); |
6de9cd9a | 821 | extern void record_vars (tree); |
50674e96 | 822 | extern bool block_may_fallthru (tree); |
6de9cd9a DN |
823 | |
824 | /* In tree-ssa-alias.c */ | |
825 | extern void dump_may_aliases_for (FILE *, tree); | |
826 | extern void debug_may_aliases_for (tree); | |
827 | extern void dump_alias_info (FILE *); | |
828 | extern void debug_alias_info (void); | |
829 | extern void dump_points_to_info (FILE *); | |
830 | extern void debug_points_to_info (void); | |
d8903b30 DN |
831 | extern void dump_points_to_info_for (FILE *, tree); |
832 | extern void debug_points_to_info_for (tree); | |
ab8907ef | 833 | extern bool may_be_aliased (tree); |
de66168d | 834 | extern struct ptr_info_def *get_ptr_info (tree); |
cc0968b0 | 835 | extern void new_type_alias (tree, tree, tree); |
e9e0aa2c DN |
836 | extern void count_uses_and_derefs (tree, tree, unsigned *, unsigned *, |
837 | unsigned *); | |
c75ab022 | 838 | static inline subvar_t get_subvars_for_var (tree); |
e8ca4159 | 839 | static inline tree get_subvar_at (tree, unsigned HOST_WIDE_INT); |
9566a759 KG |
840 | static inline bool ref_contains_array_ref (const_tree); |
841 | static inline bool array_ref_contains_indirect_ref (const_tree); | |
6bec9271 RG |
842 | extern tree get_ref_base_and_extent (tree, HOST_WIDE_INT *, |
843 | HOST_WIDE_INT *, HOST_WIDE_INT *); | |
9566a759 | 844 | static inline bool var_can_have_subvars (const_tree); |
e8ca4159 DN |
845 | static inline bool overlap_subvar (unsigned HOST_WIDE_INT, |
846 | unsigned HOST_WIDE_INT, | |
9566a759 | 847 | const_tree, bool *); |
38635499 | 848 | extern tree create_tag_raw (enum tree_code, tree, const char *); |
e9e0aa2c DN |
849 | extern void delete_mem_ref_stats (struct function *); |
850 | extern void dump_mem_ref_stats (FILE *); | |
851 | extern void debug_mem_ref_stats (void); | |
852 | extern void debug_memory_partitions (void); | |
853 | extern void debug_mem_sym_stats (tree var); | |
854 | extern void debug_all_mem_sym_stats (void); | |
013cc86f | 855 | |
6de9cd9a DN |
856 | /* Call-back function for walk_use_def_chains(). At each reaching |
857 | definition, a function with this prototype is called. */ | |
858 | typedef bool (*walk_use_def_chains_fn) (tree, tree, void *); | |
859 | ||
79bedddc SR |
860 | /* In tree-ssa-alias-warnings.c */ |
861 | extern void strict_aliasing_warning_backend (void); | |
3a2e4b46 | 862 | |
6de9cd9a DN |
863 | /* In tree-ssa.c */ |
864 | extern void init_tree_ssa (void); | |
6de9cd9a | 865 | extern edge ssa_redirect_edge (edge, basic_block); |
88957e79 | 866 | extern void flush_pending_stmts (edge); |
6de9cd9a | 867 | extern bool tree_ssa_useless_type_conversion (tree); |
36618b93 | 868 | extern bool useless_type_conversion_p (tree, tree); |
f4088621 | 869 | extern bool types_compatible_p (tree, tree); |
f430bae8 | 870 | extern void verify_ssa (bool); |
6de9cd9a | 871 | extern void delete_tree_ssa (void); |
53b4bf74 | 872 | extern void walk_use_def_chains (tree, walk_use_def_chains_fn, void *, bool); |
9beeb4ee | 873 | extern bool stmt_references_memory_p (tree); |
6de9cd9a DN |
874 | |
875 | /* In tree-into-ssa.c */ | |
0bca51f0 | 876 | void update_ssa (unsigned); |
84d65814 | 877 | void delete_update_ssa (void); |
0bca51f0 DN |
878 | void register_new_name_mapping (tree, tree); |
879 | tree create_new_def_for (tree, tree, def_operand_p); | |
880 | bool need_ssa_update_p (void); | |
8f8bb1d2 | 881 | bool name_mappings_registered_p (void); |
0bca51f0 DN |
882 | bool name_registered_for_update_p (tree); |
883 | bitmap ssa_names_to_replace (void); | |
cfaab3a9 | 884 | void release_ssa_name_after_update_ssa (tree); |
5f240ec4 ZD |
885 | void compute_global_livein (bitmap, bitmap); |
886 | tree duplicate_ssa_name (tree, tree); | |
0bca51f0 DN |
887 | void mark_sym_for_renaming (tree); |
888 | void mark_set_for_renaming (bitmap); | |
84d65814 DN |
889 | tree get_current_def (tree); |
890 | void set_current_def (tree, tree); | |
6de9cd9a | 891 | |
6de9cd9a DN |
892 | /* In tree-ssa-ccp.c */ |
893 | bool fold_stmt (tree *); | |
38965eb2 | 894 | bool fold_stmt_inplace (tree); |
6de9cd9a DN |
895 | tree widen_bitfield (tree, tree, tree); |
896 | ||
0bca51f0 | 897 | /* In tree-vrp.c */ |
0c948c27 | 898 | tree vrp_evaluate_conditional (tree, tree); |
1a557723 | 899 | void simplify_stmt_using_ranges (tree); |
0bca51f0 | 900 | |
6de9cd9a DN |
901 | /* In tree-ssa-dom.c */ |
902 | extern void dump_dominator_optimization_stats (FILE *); | |
903 | extern void debug_dominator_optimization_stats (void); | |
0bca51f0 | 904 | int loop_depth_of_name (tree); |
6de9cd9a DN |
905 | |
906 | /* In tree-ssa-copy.c */ | |
99c09897 | 907 | extern void merge_alias_info (tree, tree); |
d00ad49b AM |
908 | extern void propagate_value (use_operand_p, tree); |
909 | extern void propagate_tree_value (tree *, tree); | |
910 | extern void replace_exp (use_operand_p, tree); | |
63b88252 | 911 | extern bool may_propagate_copy (tree, tree); |
aa24864c | 912 | extern bool may_propagate_copy_into_asm (tree); |
6de9cd9a | 913 | |
17684618 ZD |
914 | /* Affine iv. */ |
915 | ||
916 | typedef struct | |
917 | { | |
918 | /* Iv = BASE + STEP * i. */ | |
919 | tree base, step; | |
920 | ||
921 | /* True if this iv does not overflow. */ | |
922 | bool no_overflow; | |
923 | } affine_iv; | |
924 | ||
e9eb809d ZD |
925 | /* Description of number of iterations of a loop. All the expressions inside |
926 | the structure can be evaluated at the end of the loop's preheader | |
927 | (and due to ssa form, also anywhere inside the body of the loop). */ | |
928 | ||
929 | struct tree_niter_desc | |
930 | { | |
6cb38cd4 | 931 | tree assumptions; /* The boolean expression. If this expression evaluates |
e9eb809d ZD |
932 | to false, then the other fields in this structure |
933 | should not be used; there is no guarantee that they | |
934 | will be correct. */ | |
2a7e31df | 935 | tree may_be_zero; /* The boolean expression. If it evaluates to true, |
e9eb809d ZD |
936 | the loop will exit in the first iteration (i.e. |
937 | its latch will not be executed), even if the niter | |
938 | field says otherwise. */ | |
939 | tree niter; /* The expression giving the number of iterations of | |
940 | a loop (provided that assumptions == true and | |
941 | may_be_zero == false), more precisely the number | |
942 | of executions of the latch of the loop. */ | |
b3ce5b6e ZD |
943 | double_int max; /* The upper bound on the number of iterations of |
944 | the loop. */ | |
17684618 ZD |
945 | |
946 | /* The simplified shape of the exit condition. The loop exits if | |
947 | CONTROL CMP BOUND is false, where CMP is one of NE_EXPR, | |
948 | LT_EXPR, or GT_EXPR, and step of CONTROL is positive if CMP is | |
949 | LE_EXPR and negative if CMP is GE_EXPR. This information is used | |
950 | by loop unrolling. */ | |
951 | affine_iv control; | |
952 | tree bound; | |
953 | enum tree_code cmp; | |
e9eb809d ZD |
954 | }; |
955 | ||
79fe1b3b | 956 | /* In tree-vectorizer.c */ |
d73be268 | 957 | unsigned vectorize_loops (void); |
0be79f24 DN |
958 | extern bool vect_can_force_dr_alignment_p (tree, unsigned int); |
959 | extern tree get_vectype_for_scalar_type (tree); | |
79fe1b3b DN |
960 | |
961 | /* In tree-ssa-phiopt.c */ | |
962 | bool empty_block_p (basic_block); | |
18d08014 | 963 | basic_block *blocks_in_phiopt_order (void); |
79fe1b3b | 964 | |
e9eb809d ZD |
965 | /* In tree-ssa-loop*.c */ |
966 | ||
d73be268 ZD |
967 | void tree_ssa_lim (void); |
968 | unsigned int tree_ssa_unswitch_loops (void); | |
969 | unsigned int canonicalize_induction_variables (void); | |
970 | unsigned int tree_unroll_loops_completely (bool); | |
971 | unsigned int tree_ssa_prefetch_arrays (void); | |
972 | unsigned int remove_empty_loops (void); | |
973 | void tree_ssa_iv_optimize (void); | |
592c303d | 974 | unsigned tree_predictive_commoning (void); |
a7e5372d | 975 | |
e9eb809d | 976 | bool number_of_iterations_exit (struct loop *, edge, |
f9cc1a70 | 977 | struct tree_niter_desc *niter, bool); |
ca4c3169 | 978 | tree find_loop_niter (struct loop *, edge *); |
e9eb809d ZD |
979 | tree loop_niter_by_eval (struct loop *, edge); |
980 | tree find_loop_niter_by_eval (struct loop *, edge *); | |
d73be268 | 981 | void estimate_numbers_of_iterations (void); |
d7f5de76 ZD |
982 | bool scev_probably_wraps_p (tree, tree, tree, struct loop *, bool); |
983 | bool convert_affine_scev (struct loop *, tree, tree *, tree *, tree, bool); | |
984 | ||
985 | bool nowrap_type_p (tree); | |
986 | enum ev_direction {EV_DIR_GROWS, EV_DIR_DECREASES, EV_DIR_UNKNOWN}; | |
987 | enum ev_direction scev_direction (tree); | |
988 | ||
d73be268 | 989 | void free_numbers_of_iterations_estimates (void); |
c9639aae | 990 | void free_numbers_of_iterations_estimates_loop (struct loop *); |
84d65814 | 991 | void rewrite_into_loop_closed_ssa (bitmap, unsigned); |
c913f08a | 992 | void verify_loop_closed_ssa (void); |
a7e5372d | 993 | bool for_each_index (tree *, bool (*) (tree, tree *, void *), void *); |
82b85a85 ZD |
994 | void create_iv (tree, tree, tree, struct loop *, block_stmt_iterator *, bool, |
995 | tree *, tree *); | |
8b11a64c | 996 | void split_loop_exit_edge (edge); |
3ac01fde | 997 | unsigned force_expr_to_var_cost (tree); |
8b11a64c ZD |
998 | void standard_iv_increment_position (struct loop *, block_stmt_iterator *, |
999 | bool *); | |
1000 | basic_block ip_end_pos (struct loop *); | |
1001 | basic_block ip_normal_pos (struct loop *); | |
d73be268 | 1002 | bool tree_duplicate_loop_to_header_edge (struct loop *, edge, |
92fc4a2f | 1003 | unsigned int, sbitmap, |
ee8c1b05 ZD |
1004 | edge, VEC (edge, heap) **, |
1005 | int); | |
d73be268 | 1006 | struct loop *tree_ssa_loop_version (struct loop *, tree, |
92fc4a2f | 1007 | basic_block *); |
d7bf3bcf | 1008 | tree expand_simple_operations (tree); |
d5ab5675 | 1009 | void substitute_in_loop_info (struct loop *, tree, tree); |
b7eae7b8 | 1010 | edge single_dom_exit (struct loop *); |
17684618 ZD |
1011 | bool can_unroll_loop_p (struct loop *loop, unsigned factor, |
1012 | struct tree_niter_desc *niter); | |
d73be268 | 1013 | void tree_unroll_loop (struct loop *, unsigned, |
17684618 | 1014 | edge, struct tree_niter_desc *); |
567b96ed ZD |
1015 | typedef void (*transform_callback)(struct loop *, void *); |
1016 | void tree_transform_and_unroll_loop (struct loop *, unsigned, | |
1017 | edge, struct tree_niter_desc *, | |
1018 | transform_callback, void *); | |
e5db3515 | 1019 | bool contains_abnormal_ssa_name_p (tree); |
bbc8a8dc | 1020 | bool stmt_dominates_stmt_p (tree, tree); |
79f5e442 | 1021 | void mark_virtual_ops_for_renaming (tree); |
e9eb809d | 1022 | |
2090d6a0 JL |
1023 | /* In tree-ssa-threadedge.c */ |
1024 | extern bool potentially_threadable_block (basic_block); | |
1025 | extern void thread_across_edge (tree, edge, bool, | |
0c948c27 | 1026 | VEC(tree, heap) **, tree (*) (tree, tree)); |
2090d6a0 | 1027 | |
40923b20 DP |
1028 | /* In tree-ssa-loop-im.c */ |
1029 | /* The possibilities of statement movement. */ | |
1030 | ||
1031 | enum move_pos | |
1032 | { | |
1033 | MOVE_IMPOSSIBLE, /* No movement -- side effect expression. */ | |
1034 | MOVE_PRESERVE_EXECUTION, /* Must not cause the non-executed statement | |
1035 | become executed -- memory accesses, ... */ | |
1036 | MOVE_POSSIBLE /* Unlimited movement. */ | |
1037 | }; | |
1038 | extern enum move_pos movement_possibility (tree); | |
bbc8a8dc | 1039 | char *get_lsm_tmp_name (tree, unsigned); |
40923b20 | 1040 | |
d16a5e36 DB |
1041 | /* The reasons a variable may escape a function. */ |
1042 | enum escape_type | |
cfaab3a9 DN |
1043 | { |
1044 | NO_ESCAPE = 0, /* Doesn't escape. */ | |
1045 | ESCAPE_STORED_IN_GLOBAL = 1 << 1, | |
1046 | ESCAPE_TO_ASM = 1 << 2, /* Passed by address to an assembly | |
1047 | statement. */ | |
1048 | ESCAPE_TO_CALL = 1 << 3, /* Escapes to a function call. */ | |
1049 | ESCAPE_BAD_CAST = 1 << 4, /* Cast from pointer to integer */ | |
1050 | ESCAPE_TO_RETURN = 1 << 5, /* Returned from function. */ | |
1051 | ESCAPE_TO_PURE_CONST = 1 << 6, /* Escapes to a pure or constant | |
1052 | function call. */ | |
1053 | ESCAPE_IS_GLOBAL = 1 << 7, /* Is a global variable. */ | |
1054 | ESCAPE_IS_PARM = 1 << 8, /* Is an incoming function argument. */ | |
1055 | ESCAPE_UNKNOWN = 1 << 9 /* We believe it escapes for | |
1056 | some reason not enumerated | |
1057 | above. */ | |
1058 | }; | |
d16a5e36 | 1059 | |
6de9cd9a | 1060 | /* In tree-flow-inline.h */ |
9566a759 | 1061 | static inline bool is_call_clobbered (const_tree); |
d16a5e36 | 1062 | static inline void mark_call_clobbered (tree, unsigned int); |
727a31fa | 1063 | static inline void set_is_used (tree); |
9566a759 | 1064 | static inline bool unmodifiable_var_p (const_tree); |
6de9cd9a DN |
1065 | |
1066 | /* In tree-eh.c */ | |
1067 | extern void make_eh_edges (tree); | |
1068 | extern bool tree_could_trap_p (tree); | |
1069 | extern bool tree_could_throw_p (tree); | |
1070 | extern bool tree_can_throw_internal (tree); | |
1071 | extern bool tree_can_throw_external (tree); | |
1eaba2f2 | 1072 | extern int lookup_stmt_eh_region (tree); |
6de9cd9a | 1073 | extern void add_stmt_to_eh_region (tree, int); |
1eaba2f2 | 1074 | extern bool remove_stmt_from_eh_region (tree); |
af47810a | 1075 | extern bool maybe_clean_or_replace_eh_stmt (tree, tree); |
6de9cd9a | 1076 | |
33c94679 DN |
1077 | /* In tree-ssa-pre.c */ |
1078 | void add_to_value (tree, tree); | |
7e6eb623 DB |
1079 | void debug_value_expressions (tree); |
1080 | void print_value_expressions (FILE *, tree); | |
b71b4522 | 1081 | |
33c94679 DN |
1082 | |
1083 | /* In tree-vn.c */ | |
89fb70a3 DB |
1084 | tree make_value_handle (tree); |
1085 | void set_value_handle (tree, tree); | |
ff2ad0f7 | 1086 | bool expressions_equal_p (tree, tree); |
83737db2 | 1087 | static inline tree get_value_handle (tree); |
c90186eb | 1088 | void sort_vuses (VEC (tree, gc) *); |
89fb70a3 DB |
1089 | void sort_vuses_heap (VEC (tree, heap) *); |
1090 | tree vn_lookup_or_add (tree); | |
1091 | tree vn_lookup_or_add_with_stmt (tree, tree); | |
c90186eb DB |
1092 | tree vn_lookup_or_add_with_vuses (tree, VEC (tree, gc) *); |
1093 | void vn_add (tree, tree); | |
1094 | void vn_add_with_vuses (tree, tree, VEC (tree, gc) *); | |
89fb70a3 DB |
1095 | tree vn_lookup_with_stmt (tree, tree); |
1096 | tree vn_lookup (tree); | |
c90186eb | 1097 | tree vn_lookup_with_vuses (tree, VEC (tree, gc) *); |
33c94679 | 1098 | |
fa555252 DB |
1099 | /* In tree-ssa-sink.c */ |
1100 | bool is_hidden_global_store (tree); | |
33c94679 | 1101 | |
242229bb | 1102 | /* In tree-sra.c */ |
88957e79 | 1103 | void insert_edge_copies (tree, basic_block); |
ea900239 DB |
1104 | void sra_insert_before (block_stmt_iterator *, tree); |
1105 | void sra_insert_after (block_stmt_iterator *, tree); | |
1106 | void sra_init_cache (void); | |
1107 | bool sra_type_can_be_decomposed_p (tree); | |
242229bb | 1108 | |
599eabdb | 1109 | /* In tree-loop-linear.c */ |
d73be268 | 1110 | extern void linear_transform_loops (void); |
599eabdb | 1111 | |
3d8864c0 SP |
1112 | /* In tree-data-ref.c */ |
1113 | extern void tree_check_data_deps (void); | |
1114 | ||
feb075f4 | 1115 | /* In tree-ssa-loop-ivopts.c */ |
ac182688 | 1116 | bool expr_invariant_in_loop_p (struct loop *, tree); |
dd5f63f8 | 1117 | bool multiplier_allowed_in_address_p (HOST_WIDE_INT, enum machine_mode); |
ac182688 | 1118 | unsigned multiply_by_cost (HOST_WIDE_INT, enum machine_mode); |
8b11a64c | 1119 | |
4aab792d | 1120 | /* In tree-ssa-threadupdate.c. */ |
b02b9b53 | 1121 | extern bool thread_through_all_blocks (bool); |
8702a557 | 1122 | extern void register_jump_thread (edge, edge); |
4aab792d | 1123 | |
9885da8e | 1124 | /* In gimplify.c */ |
8b11a64c | 1125 | tree force_gimple_operand (tree, tree *, bool, tree); |
c6540bde ZD |
1126 | tree force_gimple_operand_bsi (block_stmt_iterator *, tree, bool, tree, |
1127 | bool, enum bsi_iterator_update); | |
8b11a64c | 1128 | |
910fdc79 DB |
1129 | /* In tree-ssa-structalias.c */ |
1130 | bool find_what_p_points_to (tree); | |
1131 | ||
3f519b35 RG |
1132 | /* In tree-ssa-live.c */ |
1133 | extern void remove_unused_locals (void); | |
1134 | ||
ac182688 ZD |
1135 | /* In tree-ssa-address.c */ |
1136 | ||
ac182688 ZD |
1137 | /* Description of a memory address. */ |
1138 | ||
1139 | struct mem_address | |
1140 | { | |
1141 | tree symbol, base, index, step, offset; | |
1142 | }; | |
1143 | ||
73f30c63 | 1144 | struct affine_tree_combination; |
ac182688 ZD |
1145 | tree create_mem_ref (block_stmt_iterator *, tree, |
1146 | struct affine_tree_combination *); | |
1147 | rtx addr_for_mem_ref (struct mem_address *, bool); | |
1148 | void get_address_description (tree, struct mem_address *); | |
1149 | tree maybe_fold_tmr (tree); | |
50674e96 | 1150 | |
910fdc79 DB |
1151 | /* This structure is simply used during pushing fields onto the fieldstack |
1152 | to track the offset of the field, since bitpos_of_field gives it relative | |
1153 | to its immediate containing type, and we want it relative to the ultimate | |
1154 | containing object. */ | |
1155 | ||
1156 | struct fieldoff | |
1157 | { | |
35ed859b RG |
1158 | tree type; |
1159 | tree size; | |
1160 | tree decl; | |
910fdc79 | 1161 | HOST_WIDE_INT offset; |
4862826d | 1162 | alias_set_type alias_set; |
910fdc79 DB |
1163 | }; |
1164 | typedef struct fieldoff fieldoff_s; | |
1165 | ||
1166 | DEF_VEC_O(fieldoff_s); | |
1167 | DEF_VEC_ALLOC_O(fieldoff_s,heap); | |
1168 | int push_fields_onto_fieldstack (tree, VEC(fieldoff_s,heap) **, | |
3d9b47dc | 1169 | HOST_WIDE_INT, bool *, tree); |
910fdc79 | 1170 | void sort_fieldstack (VEC(fieldoff_s,heap) *); |
ac182688 | 1171 | |
c900f6aa DB |
1172 | void init_alias_heapvars (void); |
1173 | void delete_alias_heapvars (void); | |
873aa8f5 | 1174 | unsigned int execute_fixup_cfg (void); |
c900f6aa | 1175 | |
6de9cd9a DN |
1176 | #include "tree-flow-inline.h" |
1177 | ||
0e0ed594 JL |
1178 | void swap_tree_operands (tree, tree *, tree *); |
1179 | ||
911b3fdb ZD |
1180 | int least_common_multiple (int, int); |
1181 | ||
6de9cd9a | 1182 | #endif /* _TREE_FLOW_H */ |