|
0
|
1 /* Data and Control Flow Analysis for Trees.
|
|
|
2 Copyright (C) 2001, 2003, 2004, 2005, 2006, 2007, 2008, 2009
|
|
|
3 Free Software Foundation, Inc.
|
|
|
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
|
|
|
10 the Free Software Foundation; either version 3, or (at your option)
|
|
|
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
|
|
|
19 along with GCC; see the file COPYING3. If not see
|
|
|
20 <http://www.gnu.org/licenses/>. */
|
|
|
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"
|
|
|
29 #include "gimple.h"
|
|
|
30 #include "tree-ssa-operands.h"
|
|
|
31 #include "cgraph.h"
|
|
|
32 #include "ipa-reference.h"
|
|
|
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
|
|
|
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
|
|
|
135
|
|
|
136 /* Gimple dataflow datastructure. All publicly available fields shall have
|
|
|
137 gimple_ accessor defined in tree-flow-inline.h, all publicly modifiable
|
|
|
138 fields should have gimple_set accessor. */
|
|
|
139 struct gimple_df GTY(())
|
|
|
140 {
|
|
|
141 /* Array of all variables referenced in the function. */
|
|
|
142 htab_t GTY((param_is (union tree_node))) referenced_vars;
|
|
|
143
|
|
|
144 /* A vector of all the noreturn calls passed to modify_stmt.
|
|
|
145 cleanup_control_flow uses it to detect cases where a mid-block
|
|
|
146 indirect call has been turned into a noreturn call. When this
|
|
|
147 happens, all the instructions after the call are no longer
|
|
|
148 reachable and must be deleted as dead. */
|
|
|
149 VEC(gimple,gc) *modified_noreturn_calls;
|
|
|
150
|
|
|
151 /* Array of all SSA_NAMEs used in the function. */
|
|
|
152 VEC(tree,gc) *ssa_names;
|
|
|
153
|
|
|
154 /* Artificial variable used to model the effects of function calls. */
|
|
|
155 tree global_var;
|
|
|
156
|
|
|
157 /* Artificial variable used to model the effects of nonlocal
|
|
|
158 variables. */
|
|
|
159 tree nonlocal_all;
|
|
|
160
|
|
|
161 /* Call clobbered variables in the function. If bit I is set, then
|
|
|
162 REFERENCED_VARS (I) is call-clobbered. */
|
|
|
163 bitmap call_clobbered_vars;
|
|
|
164
|
|
|
165 /* Call-used variables in the function. If bit I is set, then
|
|
|
166 REFERENCED_VARS (I) is call-used at pure function call-sites. */
|
|
|
167 bitmap call_used_vars;
|
|
|
168
|
|
|
169 /* Addressable variables in the function. If bit I is set, then
|
|
|
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
|
|
|
178 /* Free list of SSA_NAMEs. */
|
|
|
179 tree free_ssanames;
|
|
|
180
|
|
|
181 /* 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
|
|
|
183 USE or a VUSE. In those cases, the SSA renamer creates an SSA name
|
|
|
184 for this variable with an empty defining statement. */
|
|
|
185 htab_t GTY((param_is (union tree_node))) default_defs;
|
|
|
186
|
|
|
187 /* 'true' after aliases have been computed (see compute_may_aliases). */
|
|
|
188 unsigned int aliases_computed_p : 1;
|
|
|
189
|
|
|
190 /* True if the code is in ssa form. */
|
|
|
191 unsigned int in_ssa_p : 1;
|
|
|
192
|
|
|
193 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 };
|
|
|
200
|
|
|
201 /* Accessors for internal use only. Generic code should use abstraction
|
|
|
202 provided by tree-flow-inline.h or specific modules. */
|
|
|
203 #define FREE_SSANAMES(fun) (fun)->gimple_df->free_ssanames
|
|
|
204 #define SSANAMES(fun) (fun)->gimple_df->ssa_names
|
|
|
205 #define MODIFIED_NORETURN_CALLS(fun) (fun)->gimple_df->modified_noreturn_calls
|
|
|
206 #define DEFAULT_DEFS(fun) (fun)->gimple_df->default_defs
|
|
|
207
|
|
|
208 typedef struct
|
|
|
209 {
|
|
|
210 htab_t htab;
|
|
|
211 PTR *slot;
|
|
|
212 PTR *limit;
|
|
|
213 } htab_iterator;
|
|
|
214
|
|
|
215 /* Iterate through the elements of hashtable HTAB, using htab_iterator ITER,
|
|
|
216 storing each element in RESULT, which is of type TYPE. */
|
|
|
217 #define FOR_EACH_HTAB_ELEMENT(HTAB, RESULT, TYPE, ITER) \
|
|
|
218 for (RESULT = (TYPE) first_htab_element (&(ITER), (HTAB)); \
|
|
|
219 !end_htab_p (&(ITER)); \
|
|
|
220 RESULT = (TYPE) next_htab_element (&(ITER)))
|
|
|
221
|
|
|
222 /*---------------------------------------------------------------------------
|
|
|
223 Attributes for SSA_NAMEs.
|
|
|
224
|
|
|
225 NOTE: These structures are stored in struct tree_ssa_name
|
|
|
226 but are only used by the tree optimizers, so it makes better sense
|
|
|
227 to declare them here to avoid recompiling unrelated files when
|
|
|
228 making changes.
|
|
|
229 ---------------------------------------------------------------------------*/
|
|
|
230
|
|
|
231 /* Aliasing information for SSA_NAMEs representing pointer variables. */
|
|
|
232 struct ptr_info_def GTY(())
|
|
|
233 {
|
|
|
234 /* Mask of reasons this pointer's value escapes the function. */
|
|
|
235 ENUM_BITFIELD (escape_type) escape_mask : 9;
|
|
|
236
|
|
|
237 /* Nonzero if points-to analysis couldn't determine where this pointer
|
|
|
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
|
|
|
294 /* 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
|
|
|
296 variable may need a PHI node. */
|
|
|
297
|
|
|
298 enum need_phi_state {
|
|
|
299 /* 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
|
|
|
301 needs PHI nodes. This is probably an overly conservative assumption. */
|
|
|
302 NEED_PHI_STATE_UNKNOWN,
|
|
|
303
|
|
|
304 /* 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
|
|
|
306 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
|
|
|
308 PHI nodes. */
|
|
|
309 NEED_PHI_STATE_NO,
|
|
|
310
|
|
|
311 /* This state indicates that we have either seen multiple definitions of
|
|
|
312 the variable in multiple blocks, or that we encountered a use in a
|
|
|
313 block that was not dominated by the block containing the set(s) of
|
|
|
314 this variable. This variable is assumed to need PHI nodes. */
|
|
|
315 NEED_PHI_STATE_MAYBE
|
|
|
316 };
|
|
|
317
|
|
|
318
|
|
|
319 /* The "no alias" attribute allows alias analysis to make more
|
|
|
320 aggressive assumptions when assigning alias sets, computing
|
|
|
321 points-to information and memory partitions. These attributes
|
|
|
322 are the result of user annotations or flags (e.g.,
|
|
|
323 -fargument-noalias). */
|
|
|
324 enum noalias_state {
|
|
|
325 /* Default state. No special assumptions can be made about this
|
|
|
326 symbol. */
|
|
|
327 MAY_ALIAS = 0,
|
|
|
328
|
|
|
329 /* The symbol does not alias with other symbols that have a
|
|
|
330 NO_ALIAS* attribute. */
|
|
|
331 NO_ALIAS,
|
|
|
332
|
|
|
333 /* The symbol does not alias with other symbols that have a
|
|
|
334 NO_ALIAS*, and it may not alias with global symbols. */
|
|
|
335 NO_ALIAS_GLOBAL,
|
|
|
336
|
|
|
337 /* The symbol does not alias with any other symbols. */
|
|
|
338 NO_ALIAS_ANYTHING
|
|
|
339 };
|
|
|
340
|
|
|
341
|
|
|
342 struct var_ann_d GTY(())
|
|
|
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. */
|
|
|
351 unsigned base_var_processed : 1;
|
|
|
352
|
|
|
353 /* Nonzero if this variable was used after SSA optimizations were
|
|
|
354 applied. We set this when translating out of SSA form. */
|
|
|
355 unsigned used : 1;
|
|
|
356
|
|
|
357 /* This field indicates whether or not the variable may need PHI nodes.
|
|
|
358 See the enum's definition for more detailed information about the
|
|
|
359 states. */
|
|
|
360 ENUM_BITFIELD (need_phi_state) need_phi_state : 2;
|
|
|
361
|
|
|
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
|
|
|
371 the memory area allocated by a call to malloc. */
|
|
|
372 unsigned is_heapvar : 1;
|
|
|
373
|
|
|
374 /* True if the variable is call clobbered. */
|
|
|
375 unsigned call_clobbered : 1;
|
|
|
376
|
|
|
377 /* This field describes several "no alias" attributes that some
|
|
|
378 symbols are known to have. See the enum's definition for more
|
|
|
379 information on each attribute. */
|
|
|
380 ENUM_BITFIELD (noalias_state) noalias_state : 2;
|
|
|
381
|
|
|
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. */
|
|
|
403 unsigned base_index;
|
|
|
404
|
|
|
405 /* During into-ssa and the dominator optimizer, this field holds the
|
|
|
406 current version of this variable (an SSA_NAME). */
|
|
|
407 tree current_def;
|
|
|
408 };
|
|
|
409
|
|
|
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
|
|
|
424 /* Immediate use lists are used to directly access all uses for an SSA
|
|
|
425 name and get pointers to the statement for each use.
|
|
|
426
|
|
|
427 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
|
|
|
429 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
|
|
|
431 node, it points to the SSA name itself.
|
|
|
432
|
|
|
433 The list is anchored by an occurrence of ssa_operand_d *in* the
|
|
|
434 ssa_name node itself (named 'imm_uses'). This node is uniquely
|
|
|
435 identified by having a NULL USE pointer. and the LOC pointer
|
|
|
436 pointing back to the ssa_name node itself. This node forms the
|
|
|
437 base for a circular list, and initially this is the only node in
|
|
|
438 the list.
|
|
|
439
|
|
|
440 Fast iteration allows each use to be examined, but does not allow
|
|
|
441 any modifications to the uses or stmts.
|
|
|
442
|
|
|
443 Normal iteration allows insertion, deletion, and modification. the
|
|
|
444 iterator manages this by inserting a marker node into the list
|
|
|
445 immediately before the node currently being examined in the list.
|
|
|
446 this marker node is uniquely identified by having null stmt *and* a
|
|
|
447 null use pointer.
|
|
|
448
|
|
|
449 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
|
|
|
451 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
|
|
|
453 bumping the marker node through the list). this continues until
|
|
|
454 the marker node is moved to the original anchor position. the
|
|
|
455 marker node is then removed from the list.
|
|
|
456
|
|
|
457 If iteration is halted early, the marker node must be removed from
|
|
|
458 the list before continuing. */
|
|
|
459 typedef struct immediate_use_iterator_d
|
|
|
460 {
|
|
|
461 /* This is the current use the iterator is processing. */
|
|
|
462 ssa_use_operand_t *imm_use;
|
|
|
463 /* This marks the last use in the list (use node from SSA_NAME) */
|
|
|
464 ssa_use_operand_t *end_p;
|
|
|
465 /* This node is inserted and used to mark the end of the uses for a stmt. */
|
|
|
466 ssa_use_operand_t iter_node;
|
|
|
467 /* This is the next ssa_name to visit. IMM_USE may get removed before
|
|
|
468 the next one is traversed to, so it must be cached early. */
|
|
|
469 ssa_use_operand_t *next_imm_name;
|
|
|
470 } imm_use_iterator;
|
|
|
471
|
|
|
472
|
|
|
473 /* Use this iterator when simply looking at stmts. Adding, deleting or
|
|
|
474 modifying stmts will cause this iterator to malfunction. */
|
|
|
475
|
|
|
476 #define FOR_EACH_IMM_USE_FAST(DEST, ITER, SSAVAR) \
|
|
|
477 for ((DEST) = first_readonly_imm_use (&(ITER), (SSAVAR)); \
|
|
|
478 !end_readonly_imm_use_p (&(ITER)); \
|
|
|
479 (DEST) = next_readonly_imm_use (&(ITER)))
|
|
|
480
|
|
|
481 /* Use this iterator to visit each stmt which has a use of SSAVAR. */
|
|
|
482
|
|
|
483 #define FOR_EACH_IMM_USE_STMT(STMT, ITER, SSAVAR) \
|
|
|
484 for ((STMT) = first_imm_use_stmt (&(ITER), (SSAVAR)); \
|
|
|
485 !end_imm_use_stmt_p (&(ITER)); \
|
|
|
486 (STMT) = next_imm_use_stmt (&(ITER)))
|
|
|
487
|
|
|
488 /* 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
|
|
|
490 use list, and nothing good will come from that. */
|
|
|
491 #define BREAK_FROM_IMM_USE_STMT(ITER) \
|
|
|
492 { \
|
|
|
493 end_imm_use_stmt_traverse (&(ITER)); \
|
|
|
494 break; \
|
|
|
495 }
|
|
|
496
|
|
|
497
|
|
|
498 /* 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
|
|
|
500 that iterator.. for instance:
|
|
|
501
|
|
|
502 FOR_EACH_IMM_USE_STMT (stmt, iter, var)
|
|
|
503 {
|
|
|
504 FOR_EACH_IMM_USE_ON_STMT (use_p, iter)
|
|
|
505 {
|
|
|
506 SET_USE (use_p, blah);
|
|
|
507 }
|
|
|
508 update_stmt (stmt);
|
|
|
509 } */
|
|
|
510
|
|
|
511 #define FOR_EACH_IMM_USE_ON_STMT(DEST, ITER) \
|
|
|
512 for ((DEST) = first_imm_use_on_stmt (&(ITER)); \
|
|
|
513 !end_imm_use_on_stmt_p (&(ITER)); \
|
|
|
514 (DEST) = next_imm_use_on_stmt (&(ITER)))
|
|
|
515
|
|
|
516
|
|
|
517
|
|
|
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;
|
|
|
527 typedef struct function_ann_d *function_ann_t;
|
|
|
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);
|
|
|
533 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);
|
|
|
538 static inline bitmap may_aliases (const_tree);
|
|
|
539 static inline int get_lineno (const_gimple);
|
|
|
540
|
|
|
541 /*---------------------------------------------------------------------------
|
|
|
542 Structure representing predictions in tree level.
|
|
|
543 ---------------------------------------------------------------------------*/
|
|
|
544 struct edge_prediction GTY((chain_next ("%h.ep_next")))
|
|
|
545 {
|
|
|
546 struct edge_prediction *ep_next;
|
|
|
547 edge ep_edge;
|
|
|
548 enum br_predictor ep_predictor;
|
|
|
549 int ep_probability;
|
|
|
550 };
|
|
|
551
|
|
|
552 /* Accessors for basic block annotations. */
|
|
|
553 static inline gimple_seq phi_nodes (const_basic_block);
|
|
|
554 static inline void set_phi_nodes (basic_block, gimple_seq);
|
|
|
555
|
|
|
556 /*---------------------------------------------------------------------------
|
|
|
557 Global declarations
|
|
|
558 ---------------------------------------------------------------------------*/
|
|
|
559 struct int_tree_map GTY(())
|
|
|
560 {
|
|
|
561
|
|
|
562 unsigned int uid;
|
|
|
563 tree to;
|
|
|
564 };
|
|
|
565
|
|
|
566 extern unsigned int int_tree_map_hash (const void *);
|
|
|
567 extern int int_tree_map_eq (const void *, const void *);
|
|
|
568
|
|
|
569 extern unsigned int uid_decl_map_hash (const void *);
|
|
|
570 extern int uid_decl_map_eq (const void *, const void *);
|
|
|
571
|
|
|
572 typedef struct
|
|
|
573 {
|
|
|
574 htab_iterator hti;
|
|
|
575 } referenced_var_iterator;
|
|
|
576
|
|
|
577
|
|
|
578 /* This macro loops over all the referenced vars, one at a time, putting the
|
|
|
579 current var in VAR. Note: You are not allowed to add referenced variables
|
|
|
580 to the hashtable while using this macro. Doing so may cause it to behave
|
|
|
581 erratically. */
|
|
|
582
|
|
|
583 #define FOR_EACH_REFERENCED_VAR(VAR, ITER) \
|
|
|
584 for ((VAR) = first_referenced_var (&(ITER)); \
|
|
|
585 !end_referenced_vars_p (&(ITER)); \
|
|
|
586 (VAR) = next_referenced_var (&(ITER)))
|
|
|
587
|
|
|
588
|
|
|
589 typedef struct
|
|
|
590 {
|
|
|
591 int i;
|
|
|
592 } safe_referenced_var_iterator;
|
|
|
593
|
|
|
594 /* This macro loops over all the referenced vars, one at a time, putting the
|
|
|
595 current var in VAR. You are allowed to add referenced variables during the
|
|
|
596 execution of this macro, however, the macro will not iterate over them. It
|
|
|
597 requires a temporary vector of trees, VEC, whose lifetime is controlled by
|
|
|
598 the caller. The purpose of the vector is to temporarily store the
|
|
|
599 referenced_variables hashtable so that adding referenced variables does not
|
|
|
600 affect the hashtable. */
|
|
|
601
|
|
|
602 #define FOR_EACH_REFERENCED_VAR_SAFE(VAR, VEC, ITER) \
|
|
|
603 for ((ITER).i = 0, fill_referenced_var_vec (&(VEC)); \
|
|
|
604 VEC_iterate (tree, (VEC), (ITER).i, (VAR)); \
|
|
|
605 (ITER).i++)
|
|
|
606
|
|
|
607 extern tree referenced_var_lookup (unsigned int);
|
|
|
608 extern bool referenced_var_check_and_insert (tree);
|
|
|
609 #define num_referenced_vars htab_elements (gimple_referenced_vars (cfun))
|
|
|
610 #define referenced_var(i) referenced_var_lookup (i)
|
|
|
611
|
|
|
612 #define num_ssa_names (VEC_length (tree, cfun->gimple_df->ssa_names))
|
|
|
613 #define ssa_name(i) (VEC_index (tree, cfun->gimple_df->ssa_names, (i)))
|
|
|
614
|
|
|
615 /* Macros for showing usage statistics. */
|
|
|
616 #define SCALE(x) ((unsigned long) ((x) < 1024*10 \
|
|
|
617 ? (x) \
|
|
|
618 : ((x) < 1024*1024*10 \
|
|
|
619 ? (x) / 1024 \
|
|
|
620 : (x) / (1024*1024))))
|
|
|
621
|
|
|
622 #define LABEL(x) ((x) < 1024*10 ? 'b' : ((x) < 1024*1024*10 ? 'k' : 'M'))
|
|
|
623
|
|
|
624 #define PERCENT(x,y) ((float)(x) * 100.0 / (float)(y))
|
|
|
625
|
|
|
626 /*---------------------------------------------------------------------------
|
|
|
627 OpenMP Region Tree
|
|
|
628 ---------------------------------------------------------------------------*/
|
|
|
629
|
|
|
630 /* Parallel region information. Every parallel and workshare
|
|
|
631 directive is enclosed between two markers, the OMP_* directive
|
|
|
632 and a corresponding OMP_RETURN statement. */
|
|
|
633
|
|
|
634 struct omp_region
|
|
|
635 {
|
|
|
636 /* The enclosing region. */
|
|
|
637 struct omp_region *outer;
|
|
|
638
|
|
|
639 /* First child region. */
|
|
|
640 struct omp_region *inner;
|
|
|
641
|
|
|
642 /* Next peer region. */
|
|
|
643 struct omp_region *next;
|
|
|
644
|
|
|
645 /* Block containing the omp directive as its last stmt. */
|
|
|
646 basic_block entry;
|
|
|
647
|
|
|
648 /* Block containing the OMP_RETURN as its last stmt. */
|
|
|
649 basic_block exit;
|
|
|
650
|
|
|
651 /* Block containing the OMP_CONTINUE as its last stmt. */
|
|
|
652 basic_block cont;
|
|
|
653
|
|
|
654 /* If this is a combined parallel+workshare region, this is a list
|
|
|
655 of additional arguments needed by the combined parallel+workshare
|
|
|
656 library call. */
|
|
|
657 tree ws_args;
|
|
|
658
|
|
|
659 /* The code for the omp directive of this region. */
|
|
|
660 enum gimple_code type;
|
|
|
661
|
|
|
662 /* Schedule kind, only used for OMP_FOR type regions. */
|
|
|
663 enum omp_clause_schedule_kind sched_kind;
|
|
|
664
|
|
|
665 /* True if this is a combined parallel+workshare region. */
|
|
|
666 bool is_combined_parallel;
|
|
|
667 };
|
|
|
668
|
|
|
669 extern struct omp_region *root_omp_region;
|
|
|
670 extern struct omp_region *new_omp_region (basic_block, enum gimple_code,
|
|
|
671 struct omp_region *);
|
|
|
672 extern void free_omp_regions (void);
|
|
|
673 void omp_expand_local (basic_block);
|
|
|
674 extern tree find_omp_clause (tree, enum omp_clause_code);
|
|
|
675 tree copy_var_decl (tree, tree, tree);
|
|
|
676
|
|
|
677 /*---------------------------------------------------------------------------
|
|
|
678 Function prototypes
|
|
|
679 ---------------------------------------------------------------------------*/
|
|
|
680 /* In tree-cfg.c */
|
|
|
681
|
|
|
682 /* Location to track pending stmt for edge insertion. */
|
|
|
683 #define PENDING_STMT(e) ((e)->insns.g)
|
|
|
684
|
|
|
685 extern void delete_tree_cfg_annotations (void);
|
|
|
686 extern bool stmt_ends_bb_p (gimple);
|
|
|
687 extern bool is_ctrl_stmt (gimple);
|
|
|
688 extern bool is_ctrl_altering_stmt (gimple);
|
|
|
689 extern bool simple_goto_p (gimple);
|
|
|
690 extern bool stmt_can_make_abnormal_goto (gimple);
|
|
|
691 extern basic_block single_noncomplex_succ (basic_block bb);
|
|
|
692 extern void gimple_dump_bb (basic_block, FILE *, int, int);
|
|
|
693 extern void gimple_debug_bb (basic_block);
|
|
|
694 extern basic_block gimple_debug_bb_n (int);
|
|
|
695 extern void gimple_dump_cfg (FILE *, int);
|
|
|
696 extern void gimple_debug_cfg (int);
|
|
|
697 extern void dump_cfg_stats (FILE *);
|
|
|
698 extern void dot_cfg (void);
|
|
|
699 extern void debug_cfg_stats (void);
|
|
|
700 extern void debug_loops (int);
|
|
|
701 extern void debug_loop (struct loop *, int);
|
|
|
702 extern void debug_loop_num (unsigned, int);
|
|
|
703 extern void print_loops (FILE *, int);
|
|
|
704 extern void print_loops_bb (FILE *, basic_block, int, int);
|
|
|
705 extern void cleanup_dead_labels (void);
|
|
|
706 extern void group_case_labels (void);
|
|
|
707 extern gimple first_stmt (basic_block);
|
|
|
708 extern gimple last_stmt (basic_block);
|
|
|
709 extern gimple last_and_only_stmt (basic_block);
|
|
|
710 extern edge find_taken_edge (basic_block, tree);
|
|
|
711 extern basic_block label_to_block_fn (struct function *, tree);
|
|
|
712 #define label_to_block(t) (label_to_block_fn (cfun, t))
|
|
|
713 extern void notice_special_calls (gimple);
|
|
|
714 extern void clear_special_calls (void);
|
|
|
715 extern void verify_stmts (void);
|
|
|
716 extern void verify_gimple (void);
|
|
|
717 extern void verify_types_in_gimple_seq (gimple_seq);
|
|
|
718 extern tree gimple_block_label (basic_block);
|
|
|
719 extern void extract_true_false_edges_from_block (basic_block, edge *, edge *);
|
|
|
720 extern bool gimple_duplicate_sese_region (edge, edge, basic_block *, unsigned,
|
|
|
721 basic_block *);
|
|
|
722 extern bool gimple_duplicate_sese_tail (edge, edge, basic_block *, unsigned,
|
|
|
723 basic_block *);
|
|
|
724 extern void gather_blocks_in_sese_region (basic_block entry, basic_block exit,
|
|
|
725 VEC(basic_block,heap) **bbs_p);
|
|
|
726 extern void add_phi_args_after_copy_bb (basic_block);
|
|
|
727 extern void add_phi_args_after_copy (basic_block *, unsigned, edge);
|
|
|
728 extern bool gimple_purge_dead_abnormal_call_edges (basic_block);
|
|
|
729 extern bool gimple_purge_dead_eh_edges (basic_block);
|
|
|
730 extern bool gimple_purge_all_dead_eh_edges (const_bitmap);
|
|
|
731 extern tree gimplify_build1 (gimple_stmt_iterator *, enum tree_code,
|
|
|
732 tree, tree);
|
|
|
733 extern tree gimplify_build2 (gimple_stmt_iterator *, enum tree_code,
|
|
|
734 tree, tree, tree);
|
|
|
735 extern tree gimplify_build3 (gimple_stmt_iterator *, enum tree_code,
|
|
|
736 tree, tree, tree, tree);
|
|
|
737 extern void init_empty_tree_cfg (void);
|
|
|
738 extern void init_empty_tree_cfg_for_function (struct function *);
|
|
|
739 extern void fold_cond_expr_cond (void);
|
|
|
740 extern void make_abnormal_goto_edges (basic_block, bool);
|
|
|
741 extern void replace_uses_by (tree, tree);
|
|
|
742 extern void start_recording_case_labels (void);
|
|
|
743 extern void end_recording_case_labels (void);
|
|
|
744 extern basic_block move_sese_region_to_fn (struct function *, basic_block,
|
|
|
745 basic_block, tree);
|
|
|
746 void remove_edge_and_dominated_blocks (edge);
|
|
|
747 void mark_virtual_ops_in_bb (basic_block);
|
|
|
748
|
|
|
749 /* In tree-cfgcleanup.c */
|
|
|
750 extern bitmap cfgcleanup_altered_bbs;
|
|
|
751 extern bool cleanup_tree_cfg (void);
|
|
|
752
|
|
|
753 /* In tree-pretty-print.c. */
|
|
|
754 extern void dump_generic_bb (FILE *, basic_block, int, int);
|
|
|
755 extern int op_code_prio (enum tree_code);
|
|
|
756 extern int op_prio (const_tree);
|
|
|
757 extern const char *op_symbol_code (enum tree_code);
|
|
|
758
|
|
|
759 /* In tree-dfa.c */
|
|
|
760 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);
|
|
|
763 extern tree_ann_common_t create_tree_common_ann (tree);
|
|
|
764 extern void dump_dfa_stats (FILE *);
|
|
|
765 extern void debug_dfa_stats (void);
|
|
|
766 extern void debug_referenced_vars (void);
|
|
|
767 extern void dump_referenced_vars (FILE *);
|
|
|
768 extern void dump_variable (FILE *, tree);
|
|
|
769 extern void debug_variable (tree);
|
|
|
770 extern tree get_virtual_var (tree);
|
|
|
771 extern bool add_referenced_var (tree);
|
|
|
772 extern void remove_referenced_var (tree);
|
|
|
773 extern void mark_symbols_for_renaming (gimple);
|
|
|
774 extern void find_new_referenced_vars (gimple);
|
|
|
775 extern tree make_rename_temp (tree, const char *);
|
|
|
776 extern void set_default_def (tree, tree);
|
|
|
777 extern tree gimple_default_def (struct function *, tree);
|
|
|
778 extern bool stmt_references_abnormal_ssa_name (gimple);
|
|
|
779 extern bool refs_may_alias_p (tree, tree);
|
|
|
780 extern gimple get_single_def_stmt (gimple);
|
|
|
781 extern gimple get_single_def_stmt_from_phi (tree, gimple);
|
|
|
782 extern gimple get_single_def_stmt_with_phi (tree, gimple);
|
|
|
783
|
|
|
784 /* In tree-phinodes.c */
|
|
|
785 extern void reserve_phi_args_for_new_edge (basic_block);
|
|
|
786 extern void add_phi_node_to_bb (gimple phi, basic_block bb);
|
|
|
787 extern gimple make_phi_node (tree var, int len);
|
|
|
788 extern gimple create_phi_node (tree, basic_block);
|
|
|
789 extern void add_phi_arg (gimple, tree, edge);
|
|
|
790 extern void remove_phi_args (edge);
|
|
|
791 extern void remove_phi_node (gimple_stmt_iterator *, bool);
|
|
|
792 extern void remove_phi_nodes (basic_block);
|
|
|
793 extern void init_phinodes (void);
|
|
|
794 extern void fini_phinodes (void);
|
|
|
795 extern void release_phi_node (gimple);
|
|
|
796 #ifdef GATHER_STATISTICS
|
|
|
797 extern void phinodes_print_statistics (void);
|
|
|
798 #endif
|
|
|
799
|
|
|
800 /* In gimple-low.c */
|
|
|
801 extern void record_vars_into (tree, tree);
|
|
|
802 extern void record_vars (tree);
|
|
|
803 extern bool block_may_fallthru (const_tree);
|
|
|
804 extern bool gimple_seq_may_fallthru (gimple_seq);
|
|
|
805 extern bool gimple_stmt_may_fallthru (gimple);
|
|
|
806
|
|
|
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
|
|
|
844
|
|
|
845 /* In tree-ssa.c */
|
|
|
846
|
|
|
847 /* Mapping for redirected edges. */
|
|
|
848 struct _edge_var_map GTY(())
|
|
|
849 {
|
|
|
850 tree result; /* PHI result. */
|
|
|
851 tree def; /* PHI arg definition. */
|
|
|
852 };
|
|
|
853 typedef struct _edge_var_map edge_var_map;
|
|
|
854
|
|
|
855 DEF_VEC_O(edge_var_map);
|
|
|
856 DEF_VEC_ALLOC_O(edge_var_map, heap);
|
|
|
857
|
|
|
858 /* A vector of var maps. */
|
|
|
859 typedef VEC(edge_var_map, heap) *edge_var_map_vector;
|
|
|
860
|
|
|
861 extern void init_tree_ssa (struct function *);
|
|
|
862 extern void redirect_edge_var_map_add (edge, tree, tree);
|
|
|
863 extern void redirect_edge_var_map_clear (edge);
|
|
|
864 extern void redirect_edge_var_map_dup (edge, edge);
|
|
|
865 extern edge_var_map_vector redirect_edge_var_map_vector (edge);
|
|
|
866 extern void redirect_edge_var_map_destroy (void);
|
|
|
867
|
|
|
868 extern edge ssa_redirect_edge (edge, basic_block);
|
|
|
869 extern void flush_pending_stmts (edge);
|
|
|
870 extern void verify_ssa (bool);
|
|
|
871 extern void delete_tree_ssa (void);
|
|
|
872 extern void walk_use_def_chains (tree, walk_use_def_chains_fn, void *, bool);
|
|
|
873 extern bool ssa_undefined_value_p (tree);
|
|
|
874
|
|
|
875
|
|
|
876 /* In tree-into-ssa.c */
|
|
|
877 void update_ssa (unsigned);
|
|
|
878 void delete_update_ssa (void);
|
|
|
879 void register_new_name_mapping (tree, tree);
|
|
|
880 tree create_new_def_for (tree, gimple, def_operand_p);
|
|
|
881 bool need_ssa_update_p (void);
|
|
|
882 bool name_mappings_registered_p (void);
|
|
|
883 bool name_registered_for_update_p (tree);
|
|
|
884 bitmap ssa_names_to_replace (void);
|
|
|
885 void release_ssa_name_after_update_ssa (tree);
|
|
|
886 void compute_global_livein (bitmap, bitmap);
|
|
|
887 void mark_sym_for_renaming (tree);
|
|
|
888 void mark_set_for_renaming (bitmap);
|
|
|
889 tree get_current_def (tree);
|
|
|
890 void set_current_def (tree, tree);
|
|
|
891
|
|
|
892 /* In tree-ssanames.c */
|
|
|
893 extern void init_ssanames (struct function *, int);
|
|
|
894 extern void fini_ssanames (void);
|
|
|
895 extern tree make_ssa_name_fn (struct function *, tree, gimple);
|
|
|
896 extern tree duplicate_ssa_name (tree, gimple);
|
|
|
897 extern void duplicate_ssa_name_ptr_info (tree, struct ptr_info_def *);
|
|
|
898 extern void release_ssa_name (tree);
|
|
|
899 extern void release_defs (gimple);
|
|
|
900 extern void replace_ssa_name_symbol (tree, tree);
|
|
|
901
|
|
|
902 #ifdef GATHER_STATISTICS
|
|
|
903 extern void ssanames_print_statistics (void);
|
|
|
904 #endif
|
|
|
905
|
|
|
906 /* In tree-ssa-ccp.c */
|
|
|
907 bool fold_stmt (gimple_stmt_iterator *);
|
|
|
908 bool fold_stmt_inplace (gimple);
|
|
|
909 tree get_symbol_constant_value (tree);
|
|
|
910 tree fold_const_aggregate_ref (tree);
|
|
|
911 bool may_propagate_address_into_dereference (tree, tree);
|
|
|
912
|
|
|
913
|
|
|
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 */
|
|
|
919 extern void dump_dominator_optimization_stats (FILE *);
|
|
|
920 extern void debug_dominator_optimization_stats (void);
|
|
|
921 int loop_depth_of_name (tree);
|
|
|
922
|
|
|
923 /* In tree-ssa-copy.c */
|
|
|
924 extern void merge_alias_info (tree, tree);
|
|
|
925 extern void propagate_value (use_operand_p, tree);
|
|
|
926 extern void propagate_tree_value (tree *, tree);
|
|
|
927 extern void propagate_tree_value_into_stmt (gimple_stmt_iterator *, tree);
|
|
|
928 extern void replace_exp (use_operand_p, tree);
|
|
|
929 extern bool may_propagate_copy (tree, tree);
|
|
|
930 extern bool may_propagate_copy_into_stmt (gimple, tree);
|
|
|
931 extern bool may_propagate_copy_into_asm (tree);
|
|
|
932
|
|
|
933 /* Affine iv. */
|
|
|
934
|
|
|
935 typedef struct
|
|
|
936 {
|
|
|
937 /* Iv = BASE + STEP * i. */
|
|
|
938 tree base, step;
|
|
|
939
|
|
|
940 /* True if this iv does not overflow. */
|
|
|
941 bool no_overflow;
|
|
|
942 } affine_iv;
|
|
|
943
|
|
|
944 /* Description of number of iterations of a loop. All the expressions inside
|
|
|
945 the structure can be evaluated at the end of the loop's preheader
|
|
|
946 (and due to ssa form, also anywhere inside the body of the loop). */
|
|
|
947
|
|
|
948 struct tree_niter_desc
|
|
|
949 {
|
|
|
950 tree assumptions; /* The boolean expression. If this expression evaluates
|
|
|
951 to false, then the other fields in this structure
|
|
|
952 should not be used; there is no guarantee that they
|
|
|
953 will be correct. */
|
|
|
954 tree may_be_zero; /* The boolean expression. If it evaluates to true,
|
|
|
955 the loop will exit in the first iteration (i.e.
|
|
|
956 its latch will not be executed), even if the niter
|
|
|
957 field says otherwise. */
|
|
|
958 tree niter; /* The expression giving the number of iterations of
|
|
|
959 a loop (provided that assumptions == true and
|
|
|
960 may_be_zero == false), more precisely the number
|
|
|
961 of executions of the latch of the loop. */
|
|
|
962 double_int max; /* The upper bound on the number of iterations of
|
|
|
963 the loop. */
|
|
|
964
|
|
|
965 /* The simplified shape of the exit condition. The loop exits if
|
|
|
966 CONTROL CMP BOUND is false, where CMP is one of NE_EXPR,
|
|
|
967 LT_EXPR, or GT_EXPR, and step of CONTROL is positive if CMP is
|
|
|
968 LE_EXPR and negative if CMP is GE_EXPR. This information is used
|
|
|
969 by loop unrolling. */
|
|
|
970 affine_iv control;
|
|
|
971 tree bound;
|
|
|
972 enum tree_code cmp;
|
|
|
973 };
|
|
|
974
|
|
|
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 */
|
|
|
981 bool empty_block_p (basic_block);
|
|
|
982 basic_block *blocks_in_phiopt_order (void);
|
|
|
983
|
|
|
984 /* In tree-ssa-loop*.c */
|
|
|
985
|
|
|
986 void tree_ssa_lim (void);
|
|
|
987 unsigned int tree_ssa_unswitch_loops (void);
|
|
|
988 unsigned int canonicalize_induction_variables (void);
|
|
|
989 unsigned int tree_unroll_loops_completely (bool, bool);
|
|
|
990 unsigned int tree_ssa_prefetch_arrays (void);
|
|
|
991 unsigned int remove_empty_loops (void);
|
|
|
992 void tree_ssa_iv_optimize (void);
|
|
|
993 unsigned tree_predictive_commoning (void);
|
|
|
994 tree canonicalize_loop_ivs (struct loop *, htab_t, tree *);
|
|
|
995 bool parallelize_loops (void);
|
|
|
996
|
|
|
997 bool loop_only_exit_p (const struct loop *, const_edge);
|
|
|
998 bool number_of_iterations_exit (struct loop *, edge,
|
|
|
999 struct tree_niter_desc *niter, bool);
|
|
|
1000 tree find_loop_niter (struct loop *, edge *);
|
|
|
1001 tree loop_niter_by_eval (struct loop *, edge);
|
|
|
1002 tree find_loop_niter_by_eval (struct loop *, edge *);
|
|
|
1003 void estimate_numbers_of_iterations (void);
|
|
|
1004 bool scev_probably_wraps_p (tree, tree, gimple, struct loop *, bool);
|
|
|
1005 bool convert_affine_scev (struct loop *, tree, tree *, tree *, gimple, bool);
|
|
|
1006
|
|
|
1007 bool nowrap_type_p (tree);
|
|
|
1008 enum ev_direction {EV_DIR_GROWS, EV_DIR_DECREASES, EV_DIR_UNKNOWN};
|
|
|
1009 enum ev_direction scev_direction (const_tree);
|
|
|
1010
|
|
|
1011 void free_numbers_of_iterations_estimates (void);
|
|
|
1012 void free_numbers_of_iterations_estimates_loop (struct loop *);
|
|
|
1013 void rewrite_into_loop_closed_ssa (bitmap, unsigned);
|
|
|
1014 void verify_loop_closed_ssa (void);
|
|
|
1015 bool for_each_index (tree *, bool (*) (tree, tree *, void *), void *);
|
|
|
1016 void create_iv (tree, tree, tree, struct loop *, gimple_stmt_iterator *, bool,
|
|
|
1017 tree *, tree *);
|
|
|
1018 basic_block split_loop_exit_edge (edge);
|
|
|
1019 void standard_iv_increment_position (struct loop *, gimple_stmt_iterator *,
|
|
|
1020 bool *);
|
|
|
1021 basic_block ip_end_pos (struct loop *);
|
|
|
1022 basic_block ip_normal_pos (struct loop *);
|
|
|
1023 bool gimple_duplicate_loop_to_header_edge (struct loop *, edge,
|
|
|
1024 unsigned int, sbitmap,
|
|
|
1025 edge, VEC (edge, heap) **,
|
|
|
1026 int);
|
|
|
1027 struct loop *slpeel_tree_duplicate_loop_to_edge_cfg (struct loop *, edge);
|
|
|
1028 void rename_variables_in_loop (struct loop *);
|
|
|
1029 void rename_variables_in_bb (basic_block bb);
|
|
|
1030 struct loop *tree_ssa_loop_version (struct loop *, tree,
|
|
|
1031 basic_block *);
|
|
|
1032 tree expand_simple_operations (tree);
|
|
|
1033 void substitute_in_loop_info (struct loop *, tree, tree);
|
|
|
1034 edge single_dom_exit (struct loop *);
|
|
|
1035 bool can_unroll_loop_p (struct loop *loop, unsigned factor,
|
|
|
1036 struct tree_niter_desc *niter);
|
|
|
1037 void tree_unroll_loop (struct loop *, unsigned,
|
|
|
1038 edge, struct tree_niter_desc *);
|
|
|
1039 typedef void (*transform_callback)(struct loop *, void *);
|
|
|
1040 void tree_transform_and_unroll_loop (struct loop *, unsigned,
|
|
|
1041 edge, struct tree_niter_desc *,
|
|
|
1042 transform_callback, void *);
|
|
|
1043 bool contains_abnormal_ssa_name_p (tree);
|
|
|
1044 bool stmt_dominates_stmt_p (gimple, gimple);
|
|
|
1045 void mark_virtual_ops_for_renaming (gimple);
|
|
|
1046
|
|
|
1047 /* In tree-ssa-threadedge.c */
|
|
|
1048 extern bool potentially_threadable_block (basic_block);
|
|
|
1049 extern void thread_across_edge (gimple, edge, bool,
|
|
|
1050 VEC(tree, heap) **, tree (*) (gimple, gimple));
|
|
|
1051
|
|
|
1052 /* In tree-ssa-loop-im.c */
|
|
|
1053 /* The possibilities of statement movement. */
|
|
|
1054
|
|
|
1055 enum move_pos
|
|
|
1056 {
|
|
|
1057 MOVE_IMPOSSIBLE, /* No movement -- side effect expression. */
|
|
|
1058 MOVE_PRESERVE_EXECUTION, /* Must not cause the non-executed statement
|
|
|
1059 become executed -- memory accesses, ... */
|
|
|
1060 MOVE_POSSIBLE /* Unlimited movement. */
|
|
|
1061 };
|
|
|
1062 extern enum move_pos movement_possibility (gimple);
|
|
|
1063 char *get_lsm_tmp_name (tree, unsigned);
|
|
|
1064
|
|
|
1065 /* In tree-flow-inline.h */
|
|
|
1066 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);
|
|
|
1069 static inline bool unmodifiable_var_p (const_tree);
|
|
|
1070
|
|
|
1071 /* In tree-eh.c */
|
|
|
1072 extern void make_eh_edges (gimple);
|
|
|
1073 extern bool tree_could_trap_p (tree);
|
|
|
1074 extern bool operation_could_trap_helper_p (enum tree_code, bool, bool, bool,
|
|
|
1075 bool, tree, bool *);
|
|
|
1076 extern bool operation_could_trap_p (enum tree_code, bool, bool, tree);
|
|
|
1077 extern bool stmt_could_throw_p (gimple);
|
|
|
1078 extern bool tree_could_throw_p (tree);
|
|
|
1079 extern bool stmt_can_throw_internal (gimple);
|
|
|
1080 extern void add_stmt_to_eh_region (gimple, int);
|
|
|
1081 extern bool remove_stmt_from_eh_region (gimple);
|
|
|
1082 extern bool maybe_clean_or_replace_eh_stmt (gimple, gimple);
|
|
|
1083 extern void add_stmt_to_eh_region_fn (struct function *, gimple, int);
|
|
|
1084 extern bool remove_stmt_from_eh_region_fn (struct function *, gimple);
|
|
|
1085 extern int lookup_stmt_eh_region_fn (struct function *, gimple);
|
|
|
1086 extern int lookup_expr_eh_region (tree);
|
|
|
1087 extern int lookup_stmt_eh_region (gimple);
|
|
|
1088 extern bool verify_eh_edges (gimple);
|
|
|
1089
|
|
|
1090
|
|
|
1091 /* In tree-ssa-pre.c */
|
|
|
1092 struct pre_expr_d;
|
|
|
1093 void add_to_value (unsigned int, struct pre_expr_d *);
|
|
|
1094 void debug_value_expressions (unsigned int);
|
|
|
1095 void print_value_expressions (FILE *, unsigned int);
|
|
|
1096
|
|
|
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 */
|
|
|
1114 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
|
|
|
1123 /* In tree-loop-linear.c */
|
|
|
1124 extern void linear_transform_loops (void);
|
|
|
1125 extern unsigned perfect_loop_nest_depth (struct loop *);
|
|
|
1126
|
|
|
1127 /* In graphite.c */
|
|
|
1128 extern void graphite_transform_loops (void);
|
|
|
1129
|
|
|
1130 /* In tree-data-ref.c */
|
|
|
1131 extern void tree_check_data_deps (void);
|
|
|
1132
|
|
|
1133 /* In tree-ssa-loop-ivopts.c */
|
|
|
1134 bool expr_invariant_in_loop_p (struct loop *, tree);
|
|
|
1135 bool stmt_invariant_in_loop_p (struct loop *, gimple);
|
|
|
1136 bool multiplier_allowed_in_address_p (HOST_WIDE_INT, enum machine_mode);
|
|
|
1137 unsigned multiply_by_cost (HOST_WIDE_INT, enum machine_mode, bool);
|
|
|
1138
|
|
|
1139 /* In tree-ssa-threadupdate.c. */
|
|
|
1140 extern bool thread_through_all_blocks (bool);
|
|
|
1141 extern void register_jump_thread (edge, edge);
|
|
|
1142
|
|
|
1143 /* In gimplify.c */
|
|
|
1144 tree force_gimple_operand (tree, gimple_seq *, bool, tree);
|
|
|
1145 tree force_gimple_operand_gsi (gimple_stmt_iterator *, tree, bool, tree,
|
|
|
1146 bool, enum gsi_iterator_update);
|
|
|
1147 tree gimple_fold_indirect_ref (tree);
|
|
|
1148
|
|
|
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 */
|
|
|
1155 extern void remove_unused_locals (void);
|
|
|
1156 extern void dump_scope_blocks (FILE *, int);
|
|
|
1157
|
|
|
1158 /* In tree-ssa-address.c */
|
|
|
1159
|
|
|
1160 /* Description of a memory address. */
|
|
|
1161
|
|
|
1162 struct mem_address
|
|
|
1163 {
|
|
|
1164 tree symbol, base, index, step, offset;
|
|
|
1165 };
|
|
|
1166
|
|
|
1167 struct affine_tree_combination;
|
|
|
1168 tree create_mem_ref (gimple_stmt_iterator *, tree,
|
|
|
1169 struct affine_tree_combination *, bool);
|
|
|
1170 rtx addr_for_mem_ref (struct mem_address *, bool);
|
|
|
1171 void get_address_description (tree, struct mem_address *);
|
|
|
1172 tree maybe_fold_tmr (tree);
|
|
|
1173
|
|
|
1174 void init_alias_heapvars (void);
|
|
|
1175 void delete_alias_heapvars (void);
|
|
|
1176 unsigned int execute_fixup_cfg (void);
|
|
|
1177
|
|
|
1178 #include "tree-flow-inline.h"
|
|
|
1179
|
|
|
1180 void swap_tree_operands (gimple, tree *, tree *);
|
|
|
1181
|
|
|
1182 int least_common_multiple (int, int);
|
|
|
1183
|
|
|
1184 #endif /* _TREE_FLOW_H */
|
