Mercurial > hg > CbC > CbC_gcc
comparison gcc/tree-flow.h @ 55:77e2b8dfacca gcc-4.4.5
update it from 4.4.3 to 4.5.0
author | ryoma <e075725@ie.u-ryukyu.ac.jp> |
---|---|
date | Fri, 12 Feb 2010 23:39:51 +0900 |
parents | a06113de4d67 |
children | b7f97abdc517 |
comparison
equal
deleted
inserted
replaced
52:c156f1bd5cd9 | 55:77e2b8dfacca |
---|---|
28 #include "hashtab.h" | 28 #include "hashtab.h" |
29 #include "gimple.h" | 29 #include "gimple.h" |
30 #include "tree-ssa-operands.h" | 30 #include "tree-ssa-operands.h" |
31 #include "cgraph.h" | 31 #include "cgraph.h" |
32 #include "ipa-reference.h" | 32 #include "ipa-reference.h" |
33 | 33 #include "tree-ssa-alias.h" |
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 | |
41 struct static_var_ann_d; | |
42 | |
43 /* The reasons a variable may escape a function. */ | |
44 enum escape_type | |
45 { | |
46 NO_ESCAPE = 0, /* Doesn't escape. */ | |
47 ESCAPE_STORED_IN_GLOBAL = 1 << 0, | |
48 ESCAPE_TO_ASM = 1 << 1, /* Passed by address to an assembly | |
49 statement. */ | |
50 ESCAPE_TO_CALL = 1 << 2, /* Escapes to a function call. */ | |
51 ESCAPE_BAD_CAST = 1 << 3, /* Cast from pointer to integer */ | |
52 ESCAPE_TO_RETURN = 1 << 4, /* Returned from function. */ | |
53 ESCAPE_TO_PURE_CONST = 1 << 5, /* Escapes to a pure or constant | |
54 function call. */ | |
55 ESCAPE_IS_GLOBAL = 1 << 6, /* Is a global variable. */ | |
56 ESCAPE_IS_PARM = 1 << 7, /* Is an incoming function argument. */ | |
57 ESCAPE_UNKNOWN = 1 << 8 /* We believe it escapes for | |
58 some reason not enumerated | |
59 above. */ | |
60 }; | |
61 | |
62 /* Memory reference statistics for individual memory symbols, | |
63 collected during alias analysis. */ | |
64 struct mem_sym_stats_d GTY(()) | |
65 { | |
66 /* Memory symbol. */ | |
67 tree var; | |
68 | |
69 /* Nonzero if this entry has been assigned a partition. */ | |
70 unsigned int partitioned_p : 1; | |
71 | |
72 /* Nonzero if VAR is a memory partition tag that already contains | |
73 call-clobbered variables in its partition set. */ | |
74 unsigned int has_call_clobbered_vars : 1; | |
75 | |
76 /* Number of direct reference sites. A direct reference to VAR is any | |
77 reference of the form 'VAR = ' or ' = VAR'. For GIMPLE reg | |
78 pointers, this is the number of sites where the pointer is | |
79 dereferenced. */ | |
80 long num_direct_writes; | |
81 long num_direct_reads; | |
82 | |
83 /* Number of indirect reference sites. An indirect reference to VAR | |
84 is any reference via a pointer that contains VAR in its points-to | |
85 set or, in the case of call-clobbered symbols, a function call. */ | |
86 long num_indirect_writes; | |
87 long num_indirect_reads; | |
88 | |
89 /* Execution frequency. This is the sum of the execution | |
90 frequencies of all the statements that reference this object | |
91 weighted by the number of references in each statement. This is | |
92 the main key used to sort the list of symbols to partition. | |
93 Symbols with high execution frequencies are put at the bottom of | |
94 the work list (ie, they are partitioned last). | |
95 Execution frequencies are taken directly from each basic block, | |
96 so compiling with PGO enabled will increase the precision of this | |
97 estimate. */ | |
98 long frequency_reads; | |
99 long frequency_writes; | |
100 | |
101 /* Set of memory tags that contain VAR in their alias set. */ | |
102 bitmap parent_tags; | |
103 }; | |
104 | |
105 typedef struct mem_sym_stats_d *mem_sym_stats_t; | |
106 DEF_VEC_P(mem_sym_stats_t); | |
107 DEF_VEC_ALLOC_P(mem_sym_stats_t, heap); | |
108 | |
109 /* Memory reference statistics collected during alias analysis. */ | |
110 struct mem_ref_stats_d GTY(()) | |
111 { | |
112 /* Number of statements that make memory references. */ | |
113 long num_mem_stmts; | |
114 | |
115 /* Number of statements that make function calls. */ | |
116 long num_call_sites; | |
117 | |
118 /* Number of statements that make calls to pure/const functions. */ | |
119 long num_pure_const_call_sites; | |
120 | |
121 /* Number of ASM statements. */ | |
122 long num_asm_sites; | |
123 | |
124 /* Estimated number of virtual operands needed as computed by | |
125 compute_memory_partitions. */ | |
126 long num_vuses; | |
127 long num_vdefs; | |
128 | |
129 /* This maps every symbol used to make "memory" references | |
130 (pointers, arrays, structures, etc) to an instance of struct | |
131 mem_sym_stats_d describing reference statistics for the symbol. */ | |
132 struct pointer_map_t * GTY((skip)) mem_sym_stats; | |
133 }; | |
134 | 34 |
135 | 35 |
136 /* Gimple dataflow datastructure. All publicly available fields shall have | 36 /* Gimple dataflow datastructure. All publicly available fields shall have |
137 gimple_ accessor defined in tree-flow-inline.h, all publicly modifiable | 37 gimple_ accessor defined in tree-flow-inline.h, all publicly modifiable |
138 fields should have gimple_set accessor. */ | 38 fields should have gimple_set accessor. */ |
139 struct gimple_df GTY(()) | 39 struct GTY(()) gimple_df { |
140 { | |
141 /* Array of all variables referenced in the function. */ | 40 /* Array of all variables referenced in the function. */ |
142 htab_t GTY((param_is (union tree_node))) referenced_vars; | 41 htab_t GTY((param_is (union tree_node))) referenced_vars; |
143 | 42 |
144 /* A vector of all the noreturn calls passed to modify_stmt. | 43 /* A vector of all the noreturn calls passed to modify_stmt. |
145 cleanup_control_flow uses it to detect cases where a mid-block | 44 cleanup_control_flow uses it to detect cases where a mid-block |
149 VEC(gimple,gc) *modified_noreturn_calls; | 48 VEC(gimple,gc) *modified_noreturn_calls; |
150 | 49 |
151 /* Array of all SSA_NAMEs used in the function. */ | 50 /* Array of all SSA_NAMEs used in the function. */ |
152 VEC(tree,gc) *ssa_names; | 51 VEC(tree,gc) *ssa_names; |
153 | 52 |
154 /* Artificial variable used to model the effects of function calls. */ | 53 /* Artificial variable used for the virtual operand FUD chain. */ |
155 tree global_var; | 54 tree vop; |
156 | 55 |
157 /* Artificial variable used to model the effects of nonlocal | 56 /* Artificial variable used to model the effects of nonlocal |
158 variables. */ | 57 variables. */ |
159 tree nonlocal_all; | 58 tree nonlocal_all; |
160 | 59 |
161 /* Call clobbered variables in the function. If bit I is set, then | 60 /* The PTA solution for the ESCAPED artificial variable. */ |
162 REFERENCED_VARS (I) is call-clobbered. */ | 61 struct pt_solution escaped; |
163 bitmap call_clobbered_vars; | 62 |
164 | 63 /* The PTA solution for the CALLUSED artificial variable. */ |
165 /* Call-used variables in the function. If bit I is set, then | 64 struct pt_solution callused; |
166 REFERENCED_VARS (I) is call-used at pure function call-sites. */ | 65 |
167 bitmap call_used_vars; | 66 /* A map of decls to artificial ssa-names that point to the partition |
168 | 67 of the decl. */ |
169 /* Addressable variables in the function. If bit I is set, then | 68 struct pointer_map_t * GTY((skip(""))) decls_to_pointers; |
170 REFERENCED_VARS (I) has had its address taken. Note that | |
171 CALL_CLOBBERED_VARS and ADDRESSABLE_VARS are not related. An | |
172 addressable variable is not necessarily call-clobbered (e.g., a | |
173 local addressable whose address does not escape) and not all | |
174 call-clobbered variables are addressable (e.g., a local static | |
175 variable). */ | |
176 bitmap addressable_vars; | |
177 | 69 |
178 /* Free list of SSA_NAMEs. */ | 70 /* Free list of SSA_NAMEs. */ |
179 tree free_ssanames; | 71 tree free_ssanames; |
180 | 72 |
181 /* Hashtable holding definition for symbol. If this field is not NULL, it | 73 /* Hashtable holding definition for symbol. If this field is not NULL, it |
182 means that the first reference to this variable in the function is a | 74 means that the first reference to this variable in the function is a |
183 USE or a VUSE. In those cases, the SSA renamer creates an SSA name | 75 USE or a VUSE. In those cases, the SSA renamer creates an SSA name |
184 for this variable with an empty defining statement. */ | 76 for this variable with an empty defining statement. */ |
185 htab_t GTY((param_is (union tree_node))) default_defs; | 77 htab_t GTY((param_is (union tree_node))) default_defs; |
186 | 78 |
187 /* 'true' after aliases have been computed (see compute_may_aliases). */ | 79 /* Symbols whose SSA form needs to be updated or created for the first |
188 unsigned int aliases_computed_p : 1; | 80 time. */ |
81 bitmap syms_to_rename; | |
189 | 82 |
190 /* True if the code is in ssa form. */ | 83 /* True if the code is in ssa form. */ |
191 unsigned int in_ssa_p : 1; | 84 unsigned int in_ssa_p : 1; |
192 | 85 |
193 struct ssa_operands ssa_operands; | 86 struct ssa_operands ssa_operands; |
194 | |
195 /* Memory reference statistics collected during alias analysis. | |
196 This information is used to drive the memory partitioning | |
197 heuristics in compute_memory_partitions. */ | |
198 struct mem_ref_stats_d mem_ref_stats; | |
199 }; | 87 }; |
200 | 88 |
201 /* Accessors for internal use only. Generic code should use abstraction | 89 /* Accessors for internal use only. Generic code should use abstraction |
202 provided by tree-flow-inline.h or specific modules. */ | 90 provided by tree-flow-inline.h or specific modules. */ |
203 #define FREE_SSANAMES(fun) (fun)->gimple_df->free_ssanames | 91 #define FREE_SSANAMES(fun) (fun)->gimple_df->free_ssanames |
204 #define SSANAMES(fun) (fun)->gimple_df->ssa_names | 92 #define SSANAMES(fun) (fun)->gimple_df->ssa_names |
205 #define MODIFIED_NORETURN_CALLS(fun) (fun)->gimple_df->modified_noreturn_calls | 93 #define MODIFIED_NORETURN_CALLS(fun) (fun)->gimple_df->modified_noreturn_calls |
206 #define DEFAULT_DEFS(fun) (fun)->gimple_df->default_defs | 94 #define DEFAULT_DEFS(fun) (fun)->gimple_df->default_defs |
95 #define SYMS_TO_RENAME(fun) (fun)->gimple_df->syms_to_rename | |
207 | 96 |
208 typedef struct | 97 typedef struct |
209 { | 98 { |
210 htab_t htab; | 99 htab_t htab; |
211 PTR *slot; | 100 PTR *slot; |
219 !end_htab_p (&(ITER)); \ | 108 !end_htab_p (&(ITER)); \ |
220 RESULT = (TYPE) next_htab_element (&(ITER))) | 109 RESULT = (TYPE) next_htab_element (&(ITER))) |
221 | 110 |
222 /*--------------------------------------------------------------------------- | 111 /*--------------------------------------------------------------------------- |
223 Attributes for SSA_NAMEs. | 112 Attributes for SSA_NAMEs. |
224 | 113 |
225 NOTE: These structures are stored in struct tree_ssa_name | 114 NOTE: These structures are stored in struct tree_ssa_name |
226 but are only used by the tree optimizers, so it makes better sense | 115 but are only used by the tree optimizers, so it makes better sense |
227 to declare them here to avoid recompiling unrelated files when | 116 to declare them here to avoid recompiling unrelated files when |
228 making changes. | 117 making changes. |
229 ---------------------------------------------------------------------------*/ | 118 ---------------------------------------------------------------------------*/ |
230 | 119 |
231 /* Aliasing information for SSA_NAMEs representing pointer variables. */ | 120 /* Aliasing information for SSA_NAMEs representing pointer variables. */ |
232 struct ptr_info_def GTY(()) | 121 struct GTY(()) ptr_info_def |
233 { | 122 { |
234 /* Mask of reasons this pointer's value escapes the function. */ | 123 /* The points-to solution, TBAA-pruned if the pointer is dereferenced. */ |
235 ENUM_BITFIELD (escape_type) escape_mask : 9; | 124 struct pt_solution pt; |
236 | 125 }; |
237 /* Nonzero if points-to analysis couldn't determine where this pointer | 126 |
238 is pointing to. */ | |
239 unsigned int pt_anything : 1; | |
240 | |
241 /* Nonzero if the value of this pointer escapes the current function. */ | |
242 unsigned int value_escapes_p : 1; | |
243 | |
244 /* Nonzero if a memory tag is needed for this pointer. This is | |
245 true if this pointer is eventually dereferenced. */ | |
246 unsigned int memory_tag_needed : 1; | |
247 | |
248 /* Nonzero if this pointer is really dereferenced. */ | |
249 unsigned int is_dereferenced : 1; | |
250 | |
251 /* Nonzero if this pointer points to a global variable. */ | |
252 unsigned int pt_global_mem : 1; | |
253 | |
254 /* Nonzero if this pointer points to NULL. */ | |
255 unsigned int pt_null : 1; | |
256 | |
257 /* Set of variables that this pointer may point to. */ | |
258 bitmap pt_vars; | |
259 | |
260 /* If this pointer has been dereferenced, and points-to information is | |
261 more precise than type-based aliasing, indirect references to this | |
262 pointer will be represented by this memory tag, instead of the type | |
263 tag computed by TBAA. */ | |
264 tree name_mem_tag; | |
265 }; | |
266 | |
267 | |
268 /*--------------------------------------------------------------------------- | |
269 Tree annotations stored in tree_base.ann | |
270 ---------------------------------------------------------------------------*/ | |
271 enum tree_ann_type { TREE_ANN_COMMON, VAR_ANN, FUNCTION_ANN }; | |
272 | |
273 struct tree_ann_common_d GTY(()) | |
274 { | |
275 /* Annotation type. */ | |
276 enum tree_ann_type type; | |
277 | |
278 /* Record EH region number into a statement tree created during RTL | |
279 expansion (see gimple_to_tree). */ | |
280 int rn; | |
281 | |
282 /* Auxiliary info specific to a pass. At all times, this | |
283 should either point to valid data or be NULL. */ | |
284 PTR GTY ((skip (""))) aux; | |
285 | |
286 /* The value handle for this expression. Used by GVN-PRE. */ | |
287 tree GTY((skip)) value_handle; | |
288 | |
289 /* Pointer to original GIMPLE statement. Used during RTL expansion | |
290 (see gimple_to_tree). */ | |
291 gimple stmt; | |
292 }; | |
293 | 127 |
294 /* It is advantageous to avoid things like life analysis for variables which | 128 /* It is advantageous to avoid things like life analysis for variables which |
295 do not need PHI nodes. This enum describes whether or not a particular | 129 do not need PHI nodes. This enum describes whether or not a particular |
296 variable may need a PHI node. */ | 130 variable may need a PHI node. */ |
297 | 131 |
299 /* This is the default. If we are still in this state after finding | 133 /* This is the default. If we are still in this state after finding |
300 all the definition and use sites, then we will assume the variable | 134 all the definition and use sites, then we will assume the variable |
301 needs PHI nodes. This is probably an overly conservative assumption. */ | 135 needs PHI nodes. This is probably an overly conservative assumption. */ |
302 NEED_PHI_STATE_UNKNOWN, | 136 NEED_PHI_STATE_UNKNOWN, |
303 | 137 |
304 /* This state indicates that we have seen one or more sets of the | 138 /* This state indicates that we have seen one or more sets of the |
305 variable in a single basic block and that the sets dominate all | 139 variable in a single basic block and that the sets dominate all |
306 uses seen so far. If after finding all definition and use sites | 140 uses seen so far. If after finding all definition and use sites |
307 we are still in this state, then the variable does not need any | 141 we are still in this state, then the variable does not need any |
308 PHI nodes. */ | 142 PHI nodes. */ |
309 NEED_PHI_STATE_NO, | 143 NEED_PHI_STATE_NO, |
337 /* The symbol does not alias with any other symbols. */ | 171 /* The symbol does not alias with any other symbols. */ |
338 NO_ALIAS_ANYTHING | 172 NO_ALIAS_ANYTHING |
339 }; | 173 }; |
340 | 174 |
341 | 175 |
342 struct var_ann_d GTY(()) | 176 struct GTY(()) var_ann_d { |
343 { | |
344 struct tree_ann_common_d common; | |
345 | |
346 /* Used by the out of SSA pass to determine whether this variable has | |
347 been seen yet or not. */ | |
348 unsigned out_of_ssa_tag : 1; | |
349 | |
350 /* Used when building base variable structures in a var_map. */ | 177 /* Used when building base variable structures in a var_map. */ |
351 unsigned base_var_processed : 1; | 178 unsigned base_var_processed : 1; |
352 | 179 |
353 /* Nonzero if this variable was used after SSA optimizations were | 180 /* Nonzero if this variable was used after SSA optimizations were |
354 applied. We set this when translating out of SSA form. */ | 181 applied. We set this when translating out of SSA form. */ |
357 /* This field indicates whether or not the variable may need PHI nodes. | 184 /* This field indicates whether or not the variable may need PHI nodes. |
358 See the enum's definition for more detailed information about the | 185 See the enum's definition for more detailed information about the |
359 states. */ | 186 states. */ |
360 ENUM_BITFIELD (need_phi_state) need_phi_state : 2; | 187 ENUM_BITFIELD (need_phi_state) need_phi_state : 2; |
361 | 188 |
362 /* Used during operand processing to determine if this variable is already | |
363 in the VUSE list. */ | |
364 unsigned in_vuse_list : 1; | |
365 | |
366 /* Used during operand processing to determine if this variable is already | |
367 in the VDEF list. */ | |
368 unsigned in_vdef_list : 1; | |
369 | |
370 /* True for HEAP artificial variables. These variables represent | 189 /* True for HEAP artificial variables. These variables represent |
371 the memory area allocated by a call to malloc. */ | 190 the memory area allocated by a call to malloc. */ |
372 unsigned is_heapvar : 1; | 191 unsigned is_heapvar : 1; |
373 | |
374 /* True if the variable is call clobbered. */ | |
375 unsigned call_clobbered : 1; | |
376 | 192 |
377 /* This field describes several "no alias" attributes that some | 193 /* This field describes several "no alias" attributes that some |
378 symbols are known to have. See the enum's definition for more | 194 symbols are known to have. See the enum's definition for more |
379 information on each attribute. */ | 195 information on each attribute. */ |
380 ENUM_BITFIELD (noalias_state) noalias_state : 2; | 196 ENUM_BITFIELD (noalias_state) noalias_state : 2; |
381 | 197 |
382 /* Mask of values saying the reasons why this variable has escaped | |
383 the function. */ | |
384 ENUM_BITFIELD (escape_type) escape_mask : 9; | |
385 | |
386 /* Memory partition tag assigned to this symbol. */ | |
387 tree mpt; | |
388 | |
389 /* If this variable is a pointer P that has been dereferenced, this | |
390 field is an artificial variable that represents the memory | |
391 location *P. Every other pointer Q that is type-compatible with | |
392 P will also have the same memory tag. If the variable is not a | |
393 pointer or if it is never dereferenced, this must be NULL. | |
394 FIXME, do we really need this here? How much slower would it be | |
395 to convert to hash table? */ | |
396 tree symbol_mem_tag; | |
397 | |
398 /* Used when going out of SSA form to indicate which partition this | |
399 variable represents storage for. */ | |
400 unsigned partition; | |
401 | |
402 /* Used by var_map for the base index of ssa base variables. */ | 198 /* Used by var_map for the base index of ssa base variables. */ |
403 unsigned base_index; | 199 unsigned base_index; |
404 | 200 |
405 /* During into-ssa and the dominator optimizer, this field holds the | 201 /* During into-ssa and the dominator optimizer, this field holds the |
406 current version of this variable (an SSA_NAME). */ | 202 current version of this variable (an SSA_NAME). */ |
407 tree current_def; | 203 tree current_def; |
408 }; | 204 }; |
409 | 205 |
410 /* Container for variable annotation used by hashtable for annotations for | |
411 static variables. */ | |
412 struct static_var_ann_d GTY(()) | |
413 { | |
414 struct var_ann_d ann; | |
415 unsigned int uid; | |
416 }; | |
417 | |
418 struct function_ann_d GTY(()) | |
419 { | |
420 struct tree_ann_common_d common; | |
421 }; | |
422 | |
423 | 206 |
424 /* Immediate use lists are used to directly access all uses for an SSA | 207 /* Immediate use lists are used to directly access all uses for an SSA |
425 name and get pointers to the statement for each use. | 208 name and get pointers to the statement for each use. |
426 | 209 |
427 The structure ssa_use_operand_d consists of PREV and NEXT pointers | 210 The structure ssa_use_operand_d consists of PREV and NEXT pointers |
428 to maintain the list. A USE pointer, which points to address where | 211 to maintain the list. A USE pointer, which points to address where |
429 the use is located and a LOC pointer which can point to the | 212 the use is located and a LOC pointer which can point to the |
430 statement where the use is located, or, in the case of the root | 213 statement where the use is located, or, in the case of the root |
442 | 225 |
443 Normal iteration allows insertion, deletion, and modification. the | 226 Normal iteration allows insertion, deletion, and modification. the |
444 iterator manages this by inserting a marker node into the list | 227 iterator manages this by inserting a marker node into the list |
445 immediately before the node currently being examined in the list. | 228 immediately before the node currently being examined in the list. |
446 this marker node is uniquely identified by having null stmt *and* a | 229 this marker node is uniquely identified by having null stmt *and* a |
447 null use pointer. | 230 null use pointer. |
448 | 231 |
449 When iterating to the next use, the iteration routines check to see | 232 When iterating to the next use, the iteration routines check to see |
450 if the node after the marker has changed. if it has, then the node | 233 if the node after the marker has changed. if it has, then the node |
451 following the marker is now the next one to be visited. if not, the | 234 following the marker is now the next one to be visited. if not, the |
452 marker node is moved past that node in the list (visualize it as | 235 marker node is moved past that node in the list (visualize it as |
475 | 258 |
476 #define FOR_EACH_IMM_USE_FAST(DEST, ITER, SSAVAR) \ | 259 #define FOR_EACH_IMM_USE_FAST(DEST, ITER, SSAVAR) \ |
477 for ((DEST) = first_readonly_imm_use (&(ITER), (SSAVAR)); \ | 260 for ((DEST) = first_readonly_imm_use (&(ITER), (SSAVAR)); \ |
478 !end_readonly_imm_use_p (&(ITER)); \ | 261 !end_readonly_imm_use_p (&(ITER)); \ |
479 (DEST) = next_readonly_imm_use (&(ITER))) | 262 (DEST) = next_readonly_imm_use (&(ITER))) |
480 | 263 |
481 /* Use this iterator to visit each stmt which has a use of SSAVAR. */ | 264 /* Use this iterator to visit each stmt which has a use of SSAVAR. */ |
482 | 265 |
483 #define FOR_EACH_IMM_USE_STMT(STMT, ITER, SSAVAR) \ | 266 #define FOR_EACH_IMM_USE_STMT(STMT, ITER, SSAVAR) \ |
484 for ((STMT) = first_imm_use_stmt (&(ITER), (SSAVAR)); \ | 267 for ((STMT) = first_imm_use_stmt (&(ITER), (SSAVAR)); \ |
485 !end_imm_use_stmt_p (&(ITER)); \ | 268 !end_imm_use_stmt_p (&(ITER)); \ |
486 (STMT) = next_imm_use_stmt (&(ITER))) | 269 (STMT) = next_imm_use_stmt (&(ITER))) |
487 | 270 |
488 /* Use this to terminate the FOR_EACH_IMM_USE_STMT loop early. Failure to | 271 /* Use this to terminate the FOR_EACH_IMM_USE_STMT loop early. Failure to |
489 do so will result in leaving a iterator marker node in the immediate | 272 do so will result in leaving a iterator marker node in the immediate |
490 use list, and nothing good will come from that. */ | 273 use list, and nothing good will come from that. */ |
491 #define BREAK_FROM_IMM_USE_STMT(ITER) \ | 274 #define BREAK_FROM_IMM_USE_STMT(ITER) \ |
492 { \ | 275 { \ |
493 end_imm_use_stmt_traverse (&(ITER)); \ | 276 end_imm_use_stmt_traverse (&(ITER)); \ |
494 break; \ | 277 break; \ |
495 } | 278 } |
496 | 279 |
497 | 280 |
498 /* Use this iterator in combination with FOR_EACH_IMM_USE_STMT to | 281 /* Use this iterator in combination with FOR_EACH_IMM_USE_STMT to |
499 get access to each occurrence of ssavar on the stmt returned by | 282 get access to each occurrence of ssavar on the stmt returned by |
500 that iterator.. for instance: | 283 that iterator.. for instance: |
501 | 284 |
502 FOR_EACH_IMM_USE_STMT (stmt, iter, var) | 285 FOR_EACH_IMM_USE_STMT (stmt, iter, var) |
503 { | 286 { |
513 !end_imm_use_on_stmt_p (&(ITER)); \ | 296 !end_imm_use_on_stmt_p (&(ITER)); \ |
514 (DEST) = next_imm_use_on_stmt (&(ITER))) | 297 (DEST) = next_imm_use_on_stmt (&(ITER))) |
515 | 298 |
516 | 299 |
517 | 300 |
518 union tree_ann_d GTY((desc ("ann_type ((tree_ann_t)&%h)"))) | |
519 { | |
520 struct tree_ann_common_d GTY((tag ("TREE_ANN_COMMON"))) common; | |
521 struct var_ann_d GTY((tag ("VAR_ANN"))) vdecl; | |
522 struct function_ann_d GTY((tag ("FUNCTION_ANN"))) fdecl; | |
523 }; | |
524 | |
525 typedef union tree_ann_d *tree_ann_t; | |
526 typedef struct var_ann_d *var_ann_t; | 301 typedef struct var_ann_d *var_ann_t; |
527 typedef struct function_ann_d *function_ann_t; | 302 |
528 typedef struct tree_ann_common_d *tree_ann_common_t; | |
529 | |
530 static inline tree_ann_common_t tree_common_ann (const_tree); | |
531 static inline tree_ann_common_t get_tree_common_ann (tree); | |
532 static inline var_ann_t var_ann (const_tree); | 303 static inline var_ann_t var_ann (const_tree); |
533 static inline var_ann_t get_var_ann (tree); | 304 static inline var_ann_t get_var_ann (tree); |
534 static inline function_ann_t function_ann (const_tree); | |
535 static inline function_ann_t get_function_ann (tree); | |
536 static inline enum tree_ann_type ann_type (tree_ann_t); | |
537 static inline void update_stmt (gimple); | 305 static inline void update_stmt (gimple); |
538 static inline bitmap may_aliases (const_tree); | |
539 static inline int get_lineno (const_gimple); | 306 static inline int get_lineno (const_gimple); |
540 | 307 |
541 /*--------------------------------------------------------------------------- | 308 /*--------------------------------------------------------------------------- |
542 Structure representing predictions in tree level. | 309 Structure representing predictions in tree level. |
543 ---------------------------------------------------------------------------*/ | 310 ---------------------------------------------------------------------------*/ |
544 struct edge_prediction GTY((chain_next ("%h.ep_next"))) | 311 struct GTY((chain_next ("%h.ep_next"))) edge_prediction { |
545 { | |
546 struct edge_prediction *ep_next; | 312 struct edge_prediction *ep_next; |
547 edge ep_edge; | 313 edge ep_edge; |
548 enum br_predictor ep_predictor; | 314 enum br_predictor ep_predictor; |
549 int ep_probability; | 315 int ep_probability; |
550 }; | 316 }; |
554 static inline void set_phi_nodes (basic_block, gimple_seq); | 320 static inline void set_phi_nodes (basic_block, gimple_seq); |
555 | 321 |
556 /*--------------------------------------------------------------------------- | 322 /*--------------------------------------------------------------------------- |
557 Global declarations | 323 Global declarations |
558 ---------------------------------------------------------------------------*/ | 324 ---------------------------------------------------------------------------*/ |
559 struct int_tree_map GTY(()) | 325 struct GTY(()) int_tree_map { |
560 { | 326 |
561 | |
562 unsigned int uid; | 327 unsigned int uid; |
563 tree to; | 328 tree to; |
564 }; | 329 }; |
565 | 330 |
566 extern unsigned int int_tree_map_hash (const void *); | 331 extern unsigned int int_tree_map_hash (const void *); |
567 extern int int_tree_map_eq (const void *, const void *); | 332 extern int int_tree_map_eq (const void *, const void *); |
568 | 333 |
569 extern unsigned int uid_decl_map_hash (const void *); | 334 extern unsigned int uid_decl_map_hash (const void *); |
570 extern int uid_decl_map_eq (const void *, const void *); | 335 extern int uid_decl_map_eq (const void *, const void *); |
571 | 336 |
572 typedef struct | 337 typedef struct |
573 { | 338 { |
574 htab_iterator hti; | 339 htab_iterator hti; |
575 } referenced_var_iterator; | 340 } referenced_var_iterator; |
576 | 341 |
577 | 342 |
581 erratically. */ | 346 erratically. */ |
582 | 347 |
583 #define FOR_EACH_REFERENCED_VAR(VAR, ITER) \ | 348 #define FOR_EACH_REFERENCED_VAR(VAR, ITER) \ |
584 for ((VAR) = first_referenced_var (&(ITER)); \ | 349 for ((VAR) = first_referenced_var (&(ITER)); \ |
585 !end_referenced_vars_p (&(ITER)); \ | 350 !end_referenced_vars_p (&(ITER)); \ |
586 (VAR) = next_referenced_var (&(ITER))) | 351 (VAR) = next_referenced_var (&(ITER))) |
587 | 352 |
588 | 353 |
589 typedef struct | 354 typedef struct |
590 { | 355 { |
591 int i; | 356 int i; |
743 extern void end_recording_case_labels (void); | 508 extern void end_recording_case_labels (void); |
744 extern basic_block move_sese_region_to_fn (struct function *, basic_block, | 509 extern basic_block move_sese_region_to_fn (struct function *, basic_block, |
745 basic_block, tree); | 510 basic_block, tree); |
746 void remove_edge_and_dominated_blocks (edge); | 511 void remove_edge_and_dominated_blocks (edge); |
747 void mark_virtual_ops_in_bb (basic_block); | 512 void mark_virtual_ops_in_bb (basic_block); |
513 bool tree_node_can_be_shared (tree); | |
748 | 514 |
749 /* In tree-cfgcleanup.c */ | 515 /* In tree-cfgcleanup.c */ |
750 extern bitmap cfgcleanup_altered_bbs; | 516 extern bitmap cfgcleanup_altered_bbs; |
751 extern bool cleanup_tree_cfg (void); | 517 extern bool cleanup_tree_cfg (void); |
752 | 518 |
756 extern int op_prio (const_tree); | 522 extern int op_prio (const_tree); |
757 extern const char *op_symbol_code (enum tree_code); | 523 extern const char *op_symbol_code (enum tree_code); |
758 | 524 |
759 /* In tree-dfa.c */ | 525 /* In tree-dfa.c */ |
760 extern var_ann_t create_var_ann (tree); | 526 extern var_ann_t create_var_ann (tree); |
761 extern function_ann_t create_function_ann (tree); | |
762 extern void renumber_gimple_stmt_uids (void); | 527 extern void renumber_gimple_stmt_uids (void); |
763 extern tree_ann_common_t create_tree_common_ann (tree); | 528 extern void renumber_gimple_stmt_uids_in_blocks (basic_block *, int); |
764 extern void dump_dfa_stats (FILE *); | 529 extern void dump_dfa_stats (FILE *); |
765 extern void debug_dfa_stats (void); | 530 extern void debug_dfa_stats (void); |
766 extern void debug_referenced_vars (void); | 531 extern void debug_referenced_vars (void); |
767 extern void dump_referenced_vars (FILE *); | 532 extern void dump_referenced_vars (FILE *); |
768 extern void dump_variable (FILE *, tree); | 533 extern void dump_variable (FILE *, tree); |
774 extern void find_new_referenced_vars (gimple); | 539 extern void find_new_referenced_vars (gimple); |
775 extern tree make_rename_temp (tree, const char *); | 540 extern tree make_rename_temp (tree, const char *); |
776 extern void set_default_def (tree, tree); | 541 extern void set_default_def (tree, tree); |
777 extern tree gimple_default_def (struct function *, tree); | 542 extern tree gimple_default_def (struct function *, tree); |
778 extern bool stmt_references_abnormal_ssa_name (gimple); | 543 extern bool stmt_references_abnormal_ssa_name (gimple); |
779 extern bool refs_may_alias_p (tree, tree); | 544 extern tree get_ref_base_and_extent (tree, HOST_WIDE_INT *, |
780 extern gimple get_single_def_stmt (gimple); | 545 HOST_WIDE_INT *, HOST_WIDE_INT *); |
781 extern gimple get_single_def_stmt_from_phi (tree, gimple); | 546 extern void find_referenced_vars_in (gimple); |
782 extern gimple get_single_def_stmt_with_phi (tree, gimple); | |
783 | 547 |
784 /* In tree-phinodes.c */ | 548 /* In tree-phinodes.c */ |
785 extern void reserve_phi_args_for_new_edge (basic_block); | 549 extern void reserve_phi_args_for_new_edge (basic_block); |
786 extern void add_phi_node_to_bb (gimple phi, basic_block bb); | 550 extern void add_phi_node_to_bb (gimple phi, basic_block bb); |
787 extern gimple make_phi_node (tree var, int len); | 551 extern gimple make_phi_node (tree var, int len); |
788 extern gimple create_phi_node (tree, basic_block); | 552 extern gimple create_phi_node (tree, basic_block); |
789 extern void add_phi_arg (gimple, tree, edge); | 553 extern void add_phi_arg (gimple, tree, edge, source_location); |
790 extern void remove_phi_args (edge); | 554 extern void remove_phi_args (edge); |
791 extern void remove_phi_node (gimple_stmt_iterator *, bool); | 555 extern void remove_phi_node (gimple_stmt_iterator *, bool); |
792 extern void remove_phi_nodes (basic_block); | 556 extern void remove_phi_nodes (basic_block); |
793 extern void init_phinodes (void); | 557 extern void init_phinodes (void); |
794 extern void fini_phinodes (void); | 558 extern void fini_phinodes (void); |
801 extern void record_vars_into (tree, tree); | 565 extern void record_vars_into (tree, tree); |
802 extern void record_vars (tree); | 566 extern void record_vars (tree); |
803 extern bool block_may_fallthru (const_tree); | 567 extern bool block_may_fallthru (const_tree); |
804 extern bool gimple_seq_may_fallthru (gimple_seq); | 568 extern bool gimple_seq_may_fallthru (gimple_seq); |
805 extern bool gimple_stmt_may_fallthru (gimple); | 569 extern bool gimple_stmt_may_fallthru (gimple); |
806 | 570 extern bool gimple_check_call_args (gimple); |
807 /* In tree-ssa-alias.c */ | |
808 extern unsigned int compute_may_aliases (void); | |
809 extern void dump_may_aliases_for (FILE *, tree); | |
810 extern void debug_may_aliases_for (tree); | |
811 extern void dump_alias_info (FILE *); | |
812 extern void debug_alias_info (void); | |
813 extern void dump_points_to_info (FILE *); | |
814 extern void debug_points_to_info (void); | |
815 extern void dump_points_to_info_for (FILE *, tree); | |
816 extern void debug_points_to_info_for (tree); | |
817 extern bool may_be_aliased (tree); | |
818 extern bool may_alias_p (tree, alias_set_type, tree, alias_set_type, bool); | |
819 extern struct ptr_info_def *get_ptr_info (tree); | |
820 extern bool may_point_to_global_var (tree); | |
821 extern void new_type_alias (tree, tree, tree); | |
822 extern void count_uses_and_derefs (tree, gimple, unsigned *, unsigned *, | |
823 unsigned *); | |
824 static inline bool ref_contains_array_ref (const_tree); | |
825 static inline bool array_ref_contains_indirect_ref (const_tree); | |
826 extern tree get_ref_base_and_extent (tree, HOST_WIDE_INT *, | |
827 HOST_WIDE_INT *, HOST_WIDE_INT *); | |
828 extern tree create_tag_raw (enum tree_code, tree, const char *); | |
829 extern void delete_mem_ref_stats (struct function *); | |
830 extern void dump_mem_ref_stats (FILE *); | |
831 extern void debug_mem_ref_stats (void); | |
832 extern void debug_memory_partitions (void); | |
833 extern void debug_mem_sym_stats (tree var); | |
834 extern void dump_mem_sym_stats_for_var (FILE *, tree); | |
835 extern void debug_all_mem_sym_stats (void); | |
836 | |
837 /* Call-back function for walk_use_def_chains(). At each reaching | |
838 definition, a function with this prototype is called. */ | |
839 typedef bool (*walk_use_def_chains_fn) (tree, gimple, void *); | |
840 | |
841 /* In tree-ssa-alias-warnings.c */ | |
842 extern void strict_aliasing_warning_backend (void); | |
843 | 571 |
844 | 572 |
845 /* In tree-ssa.c */ | 573 /* In tree-ssa.c */ |
846 | 574 |
847 /* Mapping for redirected edges. */ | 575 /* Mapping for redirected edges. */ |
848 struct _edge_var_map GTY(()) | 576 struct GTY(()) _edge_var_map { |
849 { | |
850 tree result; /* PHI result. */ | 577 tree result; /* PHI result. */ |
851 tree def; /* PHI arg definition. */ | 578 tree def; /* PHI arg definition. */ |
579 source_location locus; /* PHI arg location. */ | |
852 }; | 580 }; |
853 typedef struct _edge_var_map edge_var_map; | 581 typedef struct _edge_var_map edge_var_map; |
854 | 582 |
855 DEF_VEC_O(edge_var_map); | 583 DEF_VEC_O(edge_var_map); |
856 DEF_VEC_ALLOC_O(edge_var_map, heap); | 584 DEF_VEC_ALLOC_O(edge_var_map, heap); |
857 | 585 |
858 /* A vector of var maps. */ | 586 /* A vector of var maps. */ |
859 typedef VEC(edge_var_map, heap) *edge_var_map_vector; | 587 typedef VEC(edge_var_map, heap) *edge_var_map_vector; |
860 | 588 |
861 extern void init_tree_ssa (struct function *); | 589 extern void init_tree_ssa (struct function *); |
862 extern void redirect_edge_var_map_add (edge, tree, tree); | 590 extern void redirect_edge_var_map_add (edge, tree, tree, source_location); |
863 extern void redirect_edge_var_map_clear (edge); | 591 extern void redirect_edge_var_map_clear (edge); |
864 extern void redirect_edge_var_map_dup (edge, edge); | 592 extern void redirect_edge_var_map_dup (edge, edge); |
865 extern edge_var_map_vector redirect_edge_var_map_vector (edge); | 593 extern edge_var_map_vector redirect_edge_var_map_vector (edge); |
866 extern void redirect_edge_var_map_destroy (void); | 594 extern void redirect_edge_var_map_destroy (void); |
867 | 595 |
868 extern edge ssa_redirect_edge (edge, basic_block); | 596 extern edge ssa_redirect_edge (edge, basic_block); |
869 extern void flush_pending_stmts (edge); | 597 extern void flush_pending_stmts (edge); |
870 extern void verify_ssa (bool); | 598 extern void verify_ssa (bool); |
871 extern void delete_tree_ssa (void); | 599 extern void delete_tree_ssa (void); |
600 extern bool ssa_undefined_value_p (tree); | |
601 extern void execute_update_addresses_taken (bool); | |
602 | |
603 /* Call-back function for walk_use_def_chains(). At each reaching | |
604 definition, a function with this prototype is called. */ | |
605 typedef bool (*walk_use_def_chains_fn) (tree, gimple, void *); | |
606 | |
872 extern void walk_use_def_chains (tree, walk_use_def_chains_fn, void *, bool); | 607 extern void walk_use_def_chains (tree, walk_use_def_chains_fn, void *, bool); |
873 extern bool ssa_undefined_value_p (tree); | 608 |
874 | 609 void insert_debug_temps_for_defs (gimple_stmt_iterator *); |
610 void insert_debug_temp_for_var_def (gimple_stmt_iterator *, tree); | |
611 void release_defs_bitset (bitmap toremove); | |
875 | 612 |
876 /* In tree-into-ssa.c */ | 613 /* In tree-into-ssa.c */ |
877 void update_ssa (unsigned); | 614 void update_ssa (unsigned); |
878 void delete_update_ssa (void); | 615 void delete_update_ssa (void); |
879 void register_new_name_mapping (tree, tree); | 616 void register_new_name_mapping (tree, tree); |
880 tree create_new_def_for (tree, gimple, def_operand_p); | 617 tree create_new_def_for (tree, gimple, def_operand_p); |
881 bool need_ssa_update_p (void); | 618 bool need_ssa_update_p (struct function *); |
882 bool name_mappings_registered_p (void); | 619 bool name_mappings_registered_p (void); |
883 bool name_registered_for_update_p (tree); | 620 bool name_registered_for_update_p (tree); |
884 bitmap ssa_names_to_replace (void); | 621 bitmap ssa_names_to_replace (void); |
885 void release_ssa_name_after_update_ssa (tree); | 622 void release_ssa_name_after_update_ssa (tree); |
886 void compute_global_livein (bitmap, bitmap); | 623 void compute_global_livein (bitmap, bitmap); |
909 tree get_symbol_constant_value (tree); | 646 tree get_symbol_constant_value (tree); |
910 tree fold_const_aggregate_ref (tree); | 647 tree fold_const_aggregate_ref (tree); |
911 bool may_propagate_address_into_dereference (tree, tree); | 648 bool may_propagate_address_into_dereference (tree, tree); |
912 | 649 |
913 | 650 |
914 /* In tree-vrp.c */ | |
915 tree vrp_evaluate_conditional (enum tree_code, tree, tree, gimple); | |
916 bool simplify_stmt_using_ranges (gimple_stmt_iterator *); | |
917 | |
918 /* In tree-ssa-dom.c */ | 651 /* In tree-ssa-dom.c */ |
919 extern void dump_dominator_optimization_stats (FILE *); | 652 extern void dump_dominator_optimization_stats (FILE *); |
920 extern void debug_dominator_optimization_stats (void); | 653 extern void debug_dominator_optimization_stats (void); |
921 int loop_depth_of_name (tree); | 654 int loop_depth_of_name (tree); |
655 tree degenerate_phi_result (gimple); | |
922 | 656 |
923 /* In tree-ssa-copy.c */ | 657 /* In tree-ssa-copy.c */ |
924 extern void merge_alias_info (tree, tree); | |
925 extern void propagate_value (use_operand_p, tree); | 658 extern void propagate_value (use_operand_p, tree); |
926 extern void propagate_tree_value (tree *, tree); | 659 extern void propagate_tree_value (tree *, tree); |
927 extern void propagate_tree_value_into_stmt (gimple_stmt_iterator *, tree); | 660 extern void propagate_tree_value_into_stmt (gimple_stmt_iterator *, tree); |
928 extern void replace_exp (use_operand_p, tree); | 661 extern void replace_exp (use_operand_p, tree); |
929 extern bool may_propagate_copy (tree, tree); | 662 extern bool may_propagate_copy (tree, tree); |
970 affine_iv control; | 703 affine_iv control; |
971 tree bound; | 704 tree bound; |
972 enum tree_code cmp; | 705 enum tree_code cmp; |
973 }; | 706 }; |
974 | 707 |
975 /* In tree-vectorizer.c */ | |
976 unsigned vectorize_loops (void); | |
977 extern bool vect_can_force_dr_alignment_p (const_tree, unsigned int); | |
978 extern tree get_vectype_for_scalar_type (tree); | |
979 | |
980 /* In tree-ssa-phiopt.c */ | 708 /* In tree-ssa-phiopt.c */ |
981 bool empty_block_p (basic_block); | 709 bool empty_block_p (basic_block); |
982 basic_block *blocks_in_phiopt_order (void); | 710 basic_block *blocks_in_phiopt_order (void); |
983 | 711 |
984 /* In tree-ssa-loop*.c */ | 712 /* In tree-ssa-loop*.c */ |
986 void tree_ssa_lim (void); | 714 void tree_ssa_lim (void); |
987 unsigned int tree_ssa_unswitch_loops (void); | 715 unsigned int tree_ssa_unswitch_loops (void); |
988 unsigned int canonicalize_induction_variables (void); | 716 unsigned int canonicalize_induction_variables (void); |
989 unsigned int tree_unroll_loops_completely (bool, bool); | 717 unsigned int tree_unroll_loops_completely (bool, bool); |
990 unsigned int tree_ssa_prefetch_arrays (void); | 718 unsigned int tree_ssa_prefetch_arrays (void); |
991 unsigned int remove_empty_loops (void); | |
992 void tree_ssa_iv_optimize (void); | 719 void tree_ssa_iv_optimize (void); |
993 unsigned tree_predictive_commoning (void); | 720 unsigned tree_predictive_commoning (void); |
994 tree canonicalize_loop_ivs (struct loop *, htab_t, tree *); | 721 tree canonicalize_loop_ivs (struct loop *, tree *); |
995 bool parallelize_loops (void); | 722 bool parallelize_loops (void); |
996 | 723 |
997 bool loop_only_exit_p (const struct loop *, const_edge); | 724 bool loop_only_exit_p (const struct loop *, const_edge); |
998 bool number_of_iterations_exit (struct loop *, edge, | 725 bool number_of_iterations_exit (struct loop *, edge, |
999 struct tree_niter_desc *niter, bool); | 726 struct tree_niter_desc *niter, bool); |
1000 tree find_loop_niter (struct loop *, edge *); | 727 tree find_loop_niter (struct loop *, edge *); |
1001 tree loop_niter_by_eval (struct loop *, edge); | 728 tree loop_niter_by_eval (struct loop *, edge); |
1002 tree find_loop_niter_by_eval (struct loop *, edge *); | 729 tree find_loop_niter_by_eval (struct loop *, edge *); |
1003 void estimate_numbers_of_iterations (void); | 730 void estimate_numbers_of_iterations (void); |
731 bool array_at_struct_end_p (tree); | |
1004 bool scev_probably_wraps_p (tree, tree, gimple, struct loop *, bool); | 732 bool scev_probably_wraps_p (tree, tree, gimple, struct loop *, bool); |
1005 bool convert_affine_scev (struct loop *, tree, tree *, tree *, gimple, bool); | 733 bool convert_affine_scev (struct loop *, tree, tree *, tree *, gimple, bool); |
1006 | 734 |
1007 bool nowrap_type_p (tree); | 735 bool nowrap_type_p (tree); |
1008 enum ev_direction {EV_DIR_GROWS, EV_DIR_DECREASES, EV_DIR_UNKNOWN}; | 736 enum ev_direction {EV_DIR_GROWS, EV_DIR_DECREASES, EV_DIR_UNKNOWN}; |
1042 transform_callback, void *); | 770 transform_callback, void *); |
1043 bool contains_abnormal_ssa_name_p (tree); | 771 bool contains_abnormal_ssa_name_p (tree); |
1044 bool stmt_dominates_stmt_p (gimple, gimple); | 772 bool stmt_dominates_stmt_p (gimple, gimple); |
1045 void mark_virtual_ops_for_renaming (gimple); | 773 void mark_virtual_ops_for_renaming (gimple); |
1046 | 774 |
775 /* In tree-ssa-dce.c */ | |
776 void mark_virtual_phi_result_for_renaming (gimple); | |
777 | |
1047 /* In tree-ssa-threadedge.c */ | 778 /* In tree-ssa-threadedge.c */ |
779 extern void threadedge_initialize_values (void); | |
780 extern void threadedge_finalize_values (void); | |
781 extern VEC(tree,heap) *ssa_name_values; | |
782 #define SSA_NAME_VALUE(x) \ | |
783 (SSA_NAME_VERSION(x) < VEC_length(tree, ssa_name_values) \ | |
784 ? VEC_index(tree, ssa_name_values, SSA_NAME_VERSION(x)) \ | |
785 : NULL_TREE) | |
786 extern void set_ssa_name_value (tree, tree); | |
1048 extern bool potentially_threadable_block (basic_block); | 787 extern bool potentially_threadable_block (basic_block); |
1049 extern void thread_across_edge (gimple, edge, bool, | 788 extern void thread_across_edge (gimple, edge, bool, |
1050 VEC(tree, heap) **, tree (*) (gimple, gimple)); | 789 VEC(tree, heap) **, tree (*) (gimple, gimple)); |
1051 | 790 |
1052 /* In tree-ssa-loop-im.c */ | 791 /* In tree-ssa-loop-im.c */ |
1062 extern enum move_pos movement_possibility (gimple); | 801 extern enum move_pos movement_possibility (gimple); |
1063 char *get_lsm_tmp_name (tree, unsigned); | 802 char *get_lsm_tmp_name (tree, unsigned); |
1064 | 803 |
1065 /* In tree-flow-inline.h */ | 804 /* In tree-flow-inline.h */ |
1066 static inline bool is_call_clobbered (const_tree); | 805 static inline bool is_call_clobbered (const_tree); |
1067 static inline void mark_call_clobbered (tree, unsigned int); | |
1068 static inline void set_is_used (tree); | 806 static inline void set_is_used (tree); |
1069 static inline bool unmodifiable_var_p (const_tree); | 807 static inline bool unmodifiable_var_p (const_tree); |
808 static inline bool ref_contains_array_ref (const_tree); | |
809 static inline bool array_ref_contains_indirect_ref (const_tree); | |
1070 | 810 |
1071 /* In tree-eh.c */ | 811 /* In tree-eh.c */ |
1072 extern void make_eh_edges (gimple); | 812 extern void make_eh_edges (gimple); |
813 extern bool make_eh_dispatch_edges (gimple); | |
814 extern edge redirect_eh_edge (edge, basic_block); | |
815 extern void redirect_eh_dispatch_edge (gimple, edge, basic_block); | |
1073 extern bool tree_could_trap_p (tree); | 816 extern bool tree_could_trap_p (tree); |
1074 extern bool operation_could_trap_helper_p (enum tree_code, bool, bool, bool, | 817 extern bool operation_could_trap_helper_p (enum tree_code, bool, bool, bool, |
1075 bool, tree, bool *); | 818 bool, tree, bool *); |
1076 extern bool operation_could_trap_p (enum tree_code, bool, bool, tree); | 819 extern bool operation_could_trap_p (enum tree_code, bool, bool, tree); |
1077 extern bool stmt_could_throw_p (gimple); | 820 extern bool stmt_could_throw_p (gimple); |
1078 extern bool tree_could_throw_p (tree); | 821 extern bool tree_could_throw_p (tree); |
1079 extern bool stmt_can_throw_internal (gimple); | 822 extern bool stmt_can_throw_internal (gimple); |
1080 extern void add_stmt_to_eh_region (gimple, int); | 823 extern bool stmt_can_throw_external (gimple); |
1081 extern bool remove_stmt_from_eh_region (gimple); | 824 extern void add_stmt_to_eh_lp_fn (struct function *, gimple, int); |
825 extern void add_stmt_to_eh_lp (gimple, int); | |
826 extern bool remove_stmt_from_eh_lp (gimple); | |
827 extern bool remove_stmt_from_eh_lp_fn (struct function *, gimple); | |
828 extern int lookup_stmt_eh_lp_fn (struct function *, gimple); | |
829 extern int lookup_stmt_eh_lp (gimple); | |
830 extern bool maybe_clean_eh_stmt_fn (struct function *, gimple); | |
831 extern bool maybe_clean_eh_stmt (gimple); | |
1082 extern bool maybe_clean_or_replace_eh_stmt (gimple, gimple); | 832 extern bool maybe_clean_or_replace_eh_stmt (gimple, gimple); |
1083 extern void add_stmt_to_eh_region_fn (struct function *, gimple, int); | 833 extern bool maybe_duplicate_eh_stmt_fn (struct function *, gimple, |
1084 extern bool remove_stmt_from_eh_region_fn (struct function *, gimple); | 834 struct function *, gimple, |
1085 extern int lookup_stmt_eh_region_fn (struct function *, gimple); | 835 struct pointer_map_t *, int); |
1086 extern int lookup_expr_eh_region (tree); | 836 extern bool maybe_duplicate_eh_stmt (gimple, gimple); |
1087 extern int lookup_stmt_eh_region (gimple); | |
1088 extern bool verify_eh_edges (gimple); | 837 extern bool verify_eh_edges (gimple); |
1089 | 838 extern bool verify_eh_dispatch_edge (gimple); |
1090 | 839 |
1091 /* In tree-ssa-pre.c */ | 840 /* In tree-ssa-pre.c */ |
1092 struct pre_expr_d; | 841 struct pre_expr_d; |
1093 void add_to_value (unsigned int, struct pre_expr_d *); | 842 void add_to_value (unsigned int, struct pre_expr_d *); |
1094 void debug_value_expressions (unsigned int); | 843 void debug_value_expressions (unsigned int); |
1095 void print_value_expressions (FILE *, unsigned int); | 844 void print_value_expressions (FILE *, unsigned int); |
1096 | 845 |
1097 | |
1098 /* In tree-vn.c */ | |
1099 tree make_value_handle (tree); | |
1100 void set_value_handle (tree, tree); | |
1101 bool expressions_equal_p (tree, tree); | |
1102 void sort_vuses (VEC (tree, gc) *); | |
1103 void sort_vuses_heap (VEC (tree, heap) *); | |
1104 tree vn_lookup_or_add (tree); | |
1105 tree vn_lookup_or_add_with_stmt (tree, gimple); | |
1106 tree vn_lookup_or_add_with_vuses (tree, VEC (tree, gc) *); | |
1107 void vn_add (tree, tree); | |
1108 void vn_add_with_vuses (tree, tree, VEC (tree, gc) *); | |
1109 tree vn_lookup_with_stmt (tree, gimple); | |
1110 tree vn_lookup (tree); | |
1111 tree vn_lookup_with_vuses (tree, VEC (tree, gc) *); | |
1112 | |
1113 /* In tree-ssa-sink.c */ | 846 /* In tree-ssa-sink.c */ |
1114 bool is_hidden_global_store (gimple); | 847 bool is_hidden_global_store (gimple); |
1115 | |
1116 /* In tree-sra.c */ | |
1117 void insert_edge_copies_seq (gimple_seq, basic_block); | |
1118 void sra_insert_before (gimple_stmt_iterator *, gimple_seq); | |
1119 void sra_insert_after (gimple_stmt_iterator *, gimple_seq); | |
1120 void sra_init_cache (void); | |
1121 bool sra_type_can_be_decomposed_p (tree); | |
1122 | 848 |
1123 /* In tree-loop-linear.c */ | 849 /* In tree-loop-linear.c */ |
1124 extern void linear_transform_loops (void); | 850 extern void linear_transform_loops (void); |
1125 extern unsigned perfect_loop_nest_depth (struct loop *); | 851 extern unsigned perfect_loop_nest_depth (struct loop *); |
1126 | 852 |
1131 extern void tree_check_data_deps (void); | 857 extern void tree_check_data_deps (void); |
1132 | 858 |
1133 /* In tree-ssa-loop-ivopts.c */ | 859 /* In tree-ssa-loop-ivopts.c */ |
1134 bool expr_invariant_in_loop_p (struct loop *, tree); | 860 bool expr_invariant_in_loop_p (struct loop *, tree); |
1135 bool stmt_invariant_in_loop_p (struct loop *, gimple); | 861 bool stmt_invariant_in_loop_p (struct loop *, gimple); |
1136 bool multiplier_allowed_in_address_p (HOST_WIDE_INT, enum machine_mode); | 862 bool multiplier_allowed_in_address_p (HOST_WIDE_INT, enum machine_mode, |
863 addr_space_t); | |
1137 unsigned multiply_by_cost (HOST_WIDE_INT, enum machine_mode, bool); | 864 unsigned multiply_by_cost (HOST_WIDE_INT, enum machine_mode, bool); |
1138 | 865 |
1139 /* In tree-ssa-threadupdate.c. */ | 866 /* In tree-ssa-threadupdate.c. */ |
1140 extern bool thread_through_all_blocks (bool); | 867 extern bool thread_through_all_blocks (bool); |
1141 extern void register_jump_thread (edge, edge); | 868 extern void register_jump_thread (edge, edge); |
1144 tree force_gimple_operand (tree, gimple_seq *, bool, tree); | 871 tree force_gimple_operand (tree, gimple_seq *, bool, tree); |
1145 tree force_gimple_operand_gsi (gimple_stmt_iterator *, tree, bool, tree, | 872 tree force_gimple_operand_gsi (gimple_stmt_iterator *, tree, bool, tree, |
1146 bool, enum gsi_iterator_update); | 873 bool, enum gsi_iterator_update); |
1147 tree gimple_fold_indirect_ref (tree); | 874 tree gimple_fold_indirect_ref (tree); |
1148 | 875 |
1149 /* In tree-ssa-structalias.c */ | |
1150 bool find_what_p_points_to (tree); | |
1151 bool clobber_what_escaped (void); | |
1152 void compute_call_used_vars (void); | |
1153 | |
1154 /* In tree-ssa-live.c */ | 876 /* In tree-ssa-live.c */ |
1155 extern void remove_unused_locals (void); | 877 extern void remove_unused_locals (void); |
1156 extern void dump_scope_blocks (FILE *, int); | 878 extern void dump_scope_blocks (FILE *, int); |
879 extern void debug_scope_blocks (int); | |
880 extern void debug_scope_block (tree, int); | |
1157 | 881 |
1158 /* In tree-ssa-address.c */ | 882 /* In tree-ssa-address.c */ |
1159 | 883 |
1160 /* Description of a memory address. */ | 884 /* Description of a memory address. */ |
1161 | 885 |
1163 { | 887 { |
1164 tree symbol, base, index, step, offset; | 888 tree symbol, base, index, step, offset; |
1165 }; | 889 }; |
1166 | 890 |
1167 struct affine_tree_combination; | 891 struct affine_tree_combination; |
1168 tree create_mem_ref (gimple_stmt_iterator *, tree, | 892 tree create_mem_ref (gimple_stmt_iterator *, tree, |
1169 struct affine_tree_combination *, bool); | 893 struct affine_tree_combination *, tree, bool); |
1170 rtx addr_for_mem_ref (struct mem_address *, bool); | 894 rtx addr_for_mem_ref (struct mem_address *, addr_space_t, bool); |
1171 void get_address_description (tree, struct mem_address *); | 895 void get_address_description (tree, struct mem_address *); |
1172 tree maybe_fold_tmr (tree); | 896 tree maybe_fold_tmr (tree); |
1173 | 897 |
1174 void init_alias_heapvars (void); | 898 unsigned int execute_free_datastructures (void); |
1175 void delete_alias_heapvars (void); | |
1176 unsigned int execute_fixup_cfg (void); | 899 unsigned int execute_fixup_cfg (void); |
1177 | 900 |
1178 #include "tree-flow-inline.h" | 901 #include "tree-flow-inline.h" |
1179 | 902 |
1180 void swap_tree_operands (gimple, tree *, tree *); | 903 void swap_tree_operands (gimple, tree *, tree *); |