|
0
|
1 /* SSA operands management for trees.
|
|
|
2 Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008
|
|
|
3 Free Software Foundation, Inc.
|
|
|
4
|
|
|
5 This file is part of GCC.
|
|
|
6
|
|
|
7 GCC is free software; you can redistribute it and/or modify
|
|
|
8 it under the terms of the GNU General Public License as published by
|
|
|
9 the Free Software Foundation; either version 3, or (at your option)
|
|
|
10 any later version.
|
|
|
11
|
|
|
12 GCC is distributed in the hope that it will be useful,
|
|
|
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
15 GNU General Public License for more details.
|
|
|
16
|
|
|
17 You should have received a copy of the GNU General Public License
|
|
|
18 along with GCC; see the file COPYING3. If not see
|
|
|
19 <http://www.gnu.org/licenses/>. */
|
|
|
20
|
|
|
21 #include "config.h"
|
|
|
22 #include "system.h"
|
|
|
23 #include "coretypes.h"
|
|
|
24 #include "tm.h"
|
|
|
25 #include "tree.h"
|
|
|
26 #include "flags.h"
|
|
|
27 #include "function.h"
|
|
|
28 #include "diagnostic.h"
|
|
|
29 #include "tree-flow.h"
|
|
|
30 #include "tree-inline.h"
|
|
|
31 #include "tree-pass.h"
|
|
|
32 #include "ggc.h"
|
|
|
33 #include "timevar.h"
|
|
|
34 #include "toplev.h"
|
|
|
35 #include "langhooks.h"
|
|
|
36 #include "ipa-reference.h"
|
|
1
|
37 #ifndef noCbC
|
|
|
38 #include "cbc-tree.h"
|
|
|
39 #endif
|
|
0
|
40
|
|
|
41 /* This file contains the code required to manage the operands cache of the
|
|
|
42 SSA optimizer. For every stmt, we maintain an operand cache in the stmt
|
|
|
43 annotation. This cache contains operands that will be of interest to
|
|
|
44 optimizers and other passes wishing to manipulate the IL.
|
|
|
45
|
|
|
46 The operand type are broken up into REAL and VIRTUAL operands. The real
|
|
|
47 operands are represented as pointers into the stmt's operand tree. Thus
|
|
|
48 any manipulation of the real operands will be reflected in the actual tree.
|
|
|
49 Virtual operands are represented solely in the cache, although the base
|
|
|
50 variable for the SSA_NAME may, or may not occur in the stmt's tree.
|
|
|
51 Manipulation of the virtual operands will not be reflected in the stmt tree.
|
|
|
52
|
|
|
53 The routines in this file are concerned with creating this operand cache
|
|
|
54 from a stmt tree.
|
|
|
55
|
|
|
56 The operand tree is the parsed by the various get_* routines which look
|
|
|
57 through the stmt tree for the occurrence of operands which may be of
|
|
|
58 interest, and calls are made to the append_* routines whenever one is
|
|
|
59 found. There are 4 of these routines, each representing one of the
|
|
|
60 4 types of operands. Defs, Uses, Virtual Uses, and Virtual May Defs.
|
|
|
61
|
|
|
62 The append_* routines check for duplication, and simply keep a list of
|
|
|
63 unique objects for each operand type in the build_* extendable vectors.
|
|
|
64
|
|
|
65 Once the stmt tree is completely parsed, the finalize_ssa_operands()
|
|
|
66 routine is called, which proceeds to perform the finalization routine
|
|
|
67 on each of the 4 operand vectors which have been built up.
|
|
|
68
|
|
|
69 If the stmt had a previous operand cache, the finalization routines
|
|
|
70 attempt to match up the new operands with the old ones. If it's a perfect
|
|
|
71 match, the old vector is simply reused. If it isn't a perfect match, then
|
|
|
72 a new vector is created and the new operands are placed there. For
|
|
|
73 virtual operands, if the previous cache had SSA_NAME version of a
|
|
|
74 variable, and that same variable occurs in the same operands cache, then
|
|
|
75 the new cache vector will also get the same SSA_NAME.
|
|
|
76
|
|
|
77 i.e., if a stmt had a VUSE of 'a_5', and 'a' occurs in the new
|
|
|
78 operand vector for VUSE, then the new vector will also be modified
|
|
|
79 such that it contains 'a_5' rather than 'a'. */
|
|
|
80
|
|
|
81 /* Helper functions from gimple.c. These are GIMPLE manipulation
|
|
|
82 routines that only the operand scanner should need. */
|
|
|
83 void gimple_set_stored_syms (gimple, bitmap, bitmap_obstack *);
|
|
|
84 void gimple_set_loaded_syms (gimple, bitmap, bitmap_obstack *);
|
|
|
85
|
|
|
86 /* Structure storing statistics on how many call clobbers we have, and
|
|
|
87 how many where avoided. */
|
|
|
88
|
|
|
89 static struct
|
|
|
90 {
|
|
|
91 /* Number of call-clobbered ops we attempt to add to calls in
|
|
|
92 add_call_clobbered_mem_symbols. */
|
|
|
93 unsigned int clobbered_vars;
|
|
|
94
|
|
|
95 /* Number of write-clobbers (VDEFs) avoided by using
|
|
|
96 not_written information. */
|
|
|
97 unsigned int static_write_clobbers_avoided;
|
|
|
98
|
|
|
99 /* Number of reads (VUSEs) avoided by using not_read information. */
|
|
|
100 unsigned int static_read_clobbers_avoided;
|
|
|
101
|
|
|
102 /* Number of write-clobbers avoided because the variable can't escape to
|
|
|
103 this call. */
|
|
|
104 unsigned int unescapable_clobbers_avoided;
|
|
|
105
|
|
|
106 /* Number of read-only uses we attempt to add to calls in
|
|
|
107 add_call_read_mem_symbols. */
|
|
|
108 unsigned int readonly_clobbers;
|
|
|
109
|
|
|
110 /* Number of read-only uses we avoid using not_read information. */
|
|
|
111 unsigned int static_readonly_clobbers_avoided;
|
|
|
112 } clobber_stats;
|
|
|
113
|
|
|
114
|
|
|
115 /* Flags to describe operand properties in helpers. */
|
|
|
116
|
|
|
117 /* By default, operands are loaded. */
|
|
|
118 #define opf_use 0
|
|
|
119
|
|
|
120 /* Operand is the target of an assignment expression or a
|
|
|
121 call-clobbered variable. */
|
|
|
122 #define opf_def (1 << 0)
|
|
|
123
|
|
|
124 /* No virtual operands should be created in the expression. This is used
|
|
|
125 when traversing ADDR_EXPR nodes which have different semantics than
|
|
|
126 other expressions. Inside an ADDR_EXPR node, the only operands that we
|
|
|
127 need to consider are indices into arrays. For instance, &a.b[i] should
|
|
|
128 generate a USE of 'i' but it should not generate a VUSE for 'a' nor a
|
|
|
129 VUSE for 'b'. */
|
|
|
130 #define opf_no_vops (1 << 1)
|
|
|
131
|
|
|
132 /* Operand is an implicit reference. This is used to distinguish
|
|
|
133 explicit assignments in the form of MODIFY_EXPR from
|
|
|
134 clobbering sites like function calls or ASM_EXPRs. */
|
|
|
135 #define opf_implicit (1 << 2)
|
|
|
136
|
|
|
137 /* Array for building all the def operands. */
|
|
|
138 static VEC(tree,heap) *build_defs;
|
|
|
139
|
|
|
140 /* Array for building all the use operands. */
|
|
|
141 static VEC(tree,heap) *build_uses;
|
|
|
142
|
|
|
143 /* Set for building all the VDEF operands. */
|
|
|
144 static VEC(tree,heap) *build_vdefs;
|
|
|
145
|
|
|
146 /* Set for building all the VUSE operands. */
|
|
|
147 static VEC(tree,heap) *build_vuses;
|
|
|
148
|
|
|
149 /* Bitmap obstack for our datastructures that needs to survive across
|
|
|
150 compilations of multiple functions. */
|
|
|
151 static bitmap_obstack operands_bitmap_obstack;
|
|
|
152
|
|
|
153 /* Set for building all the loaded symbols. */
|
|
|
154 static bitmap build_loads;
|
|
|
155
|
|
|
156 /* Set for building all the stored symbols. */
|
|
|
157 static bitmap build_stores;
|
|
|
158
|
|
|
159 static void get_expr_operands (gimple, tree *, int);
|
|
|
160
|
|
|
161 /* Number of functions with initialized ssa_operands. */
|
|
|
162 static int n_initialized = 0;
|
|
|
163
|
|
|
164 /* Statement change buffer. Data structure used to record state
|
|
|
165 information for statements. This is used to determine what needs
|
|
|
166 to be done in order to update the SSA web after a statement is
|
|
|
167 modified by a pass. If STMT is a statement that has just been
|
|
|
168 created, or needs to be folded via fold_stmt, or anything that
|
|
|
169 changes its physical structure then the pass should:
|
|
|
170
|
|
|
171 1- Call push_stmt_changes (&stmt) to record the current state of
|
|
|
172 STMT before any modifications are made.
|
|
|
173
|
|
|
174 2- Make all appropriate modifications to the statement.
|
|
|
175
|
|
|
176 3- Call pop_stmt_changes (&stmt) to find new symbols that
|
|
|
177 need to be put in SSA form, SSA name mappings for names that
|
|
|
178 have disappeared, recompute invariantness for address
|
|
|
179 expressions, cleanup EH information, etc.
|
|
|
180
|
|
|
181 If it is possible to determine that the statement was not modified,
|
|
|
182 instead of calling pop_stmt_changes it is quicker to call
|
|
|
183 discard_stmt_changes to avoid the expensive and unnecessary operand
|
|
|
184 re-scan and change comparison. */
|
|
|
185
|
|
|
186 struct scb_d
|
|
|
187 {
|
|
|
188 /* Pointer to the statement being modified. */
|
|
|
189 gimple *stmt_p;
|
|
|
190
|
|
|
191 /* If the statement references memory these are the sets of symbols
|
|
|
192 loaded and stored by the statement. */
|
|
|
193 bitmap loads;
|
|
|
194 bitmap stores;
|
|
|
195 };
|
|
|
196
|
|
|
197 typedef struct scb_d *scb_t;
|
|
|
198 DEF_VEC_P(scb_t);
|
|
|
199 DEF_VEC_ALLOC_P(scb_t,heap);
|
|
|
200
|
|
|
201 /* Stack of statement change buffers (SCB). Every call to
|
|
|
202 push_stmt_changes pushes a new buffer onto the stack. Calls to
|
|
|
203 pop_stmt_changes pop a buffer off of the stack and compute the set
|
|
|
204 of changes for the popped statement. */
|
|
|
205 static VEC(scb_t,heap) *scb_stack;
|
|
|
206
|
|
|
207 /* Return the DECL_UID of the base variable of T. */
|
|
|
208
|
|
|
209 static inline unsigned
|
|
|
210 get_name_decl (const_tree t)
|
|
|
211 {
|
|
|
212 if (TREE_CODE (t) != SSA_NAME)
|
|
|
213 return DECL_UID (t);
|
|
|
214 else
|
|
|
215 return DECL_UID (SSA_NAME_VAR (t));
|
|
|
216 }
|
|
|
217
|
|
|
218
|
|
|
219 /* Comparison function for qsort used in operand_build_sort_virtual. */
|
|
|
220
|
|
|
221 int
|
|
|
222 operand_build_cmp (const void *p, const void *q)
|
|
|
223 {
|
|
|
224 const_tree const e1 = *((const_tree const *)p);
|
|
|
225 const_tree const e2 = *((const_tree const *)q);
|
|
|
226 const unsigned int u1 = get_name_decl (e1);
|
|
|
227 const unsigned int u2 = get_name_decl (e2);
|
|
|
228
|
|
|
229 /* We want to sort in ascending order. They can never be equal. */
|
|
|
230 #ifdef ENABLE_CHECKING
|
|
|
231 gcc_assert (u1 != u2);
|
|
|
232 #endif
|
|
|
233 return (u1 > u2 ? 1 : -1);
|
|
|
234 }
|
|
|
235
|
|
|
236
|
|
|
237 /* Sort the virtual operands in LIST from lowest DECL_UID to highest. */
|
|
|
238
|
|
|
239 static inline void
|
|
|
240 operand_build_sort_virtual (VEC(tree,heap) *list)
|
|
|
241 {
|
|
|
242 int num = VEC_length (tree, list);
|
|
|
243
|
|
|
244 if (num < 2)
|
|
|
245 return;
|
|
|
246
|
|
|
247 if (num == 2)
|
|
|
248 {
|
|
|
249 if (get_name_decl (VEC_index (tree, list, 0))
|
|
|
250 > get_name_decl (VEC_index (tree, list, 1)))
|
|
|
251 {
|
|
|
252 /* Swap elements if in the wrong order. */
|
|
|
253 tree tmp = VEC_index (tree, list, 0);
|
|
|
254 VEC_replace (tree, list, 0, VEC_index (tree, list, 1));
|
|
|
255 VEC_replace (tree, list, 1, tmp);
|
|
|
256 }
|
|
|
257 return;
|
|
|
258 }
|
|
|
259
|
|
|
260 /* There are 3 or more elements, call qsort. */
|
|
|
261 qsort (VEC_address (tree, list),
|
|
|
262 VEC_length (tree, list),
|
|
|
263 sizeof (tree),
|
|
|
264 operand_build_cmp);
|
|
|
265 }
|
|
|
266
|
|
|
267 /* Return true if the SSA operands cache is active. */
|
|
|
268
|
|
|
269 bool
|
|
|
270 ssa_operands_active (void)
|
|
|
271 {
|
|
|
272 /* This function may be invoked from contexts where CFUN is NULL
|
|
|
273 (IPA passes), return false for now. FIXME: operands may be
|
|
|
274 active in each individual function, maybe this function should
|
|
|
275 take CFUN as a parameter. */
|
|
|
276 if (cfun == NULL)
|
|
|
277 return false;
|
|
|
278
|
|
|
279 return cfun->gimple_df && gimple_ssa_operands (cfun)->ops_active;
|
|
|
280 }
|
|
|
281
|
|
|
282
|
|
|
283 /* VOPs are of variable sized, so the free list maps "free buckets" to the
|
|
|
284 following table:
|
|
|
285 bucket # operands
|
|
|
286 ------ ----------
|
|
|
287 0 1
|
|
|
288 1 2
|
|
|
289 ...
|
|
|
290 15 16
|
|
|
291 16 17-24
|
|
|
292 17 25-32
|
|
|
293 18 31-40
|
|
|
294 ...
|
|
|
295 29 121-128
|
|
|
296 Any VOPs larger than this are simply added to the largest bucket when they
|
|
|
297 are freed. */
|
|
|
298
|
|
|
299
|
|
|
300 /* Return the number of operands used in bucket BUCKET. */
|
|
|
301
|
|
|
302 static inline int
|
|
|
303 vop_free_bucket_size (int bucket)
|
|
|
304 {
|
|
|
305 #ifdef ENABLE_CHECKING
|
|
|
306 gcc_assert (bucket >= 0 && bucket < NUM_VOP_FREE_BUCKETS);
|
|
|
307 #endif
|
|
|
308 if (bucket < 16)
|
|
|
309 return bucket + 1;
|
|
|
310 return (bucket - 13) * 8;
|
|
|
311 }
|
|
|
312
|
|
|
313
|
|
|
314 /* For a vop of NUM operands, return the bucket NUM belongs to. If NUM is
|
|
|
315 beyond the end of the bucket table, return -1. */
|
|
|
316
|
|
|
317 static inline int
|
|
|
318 vop_free_bucket_index (int num)
|
|
|
319 {
|
|
|
320 gcc_assert (num > 0 && NUM_VOP_FREE_BUCKETS > 16);
|
|
|
321
|
|
|
322 /* Sizes 1 through 16 use buckets 0-15. */
|
|
|
323 if (num <= 16)
|
|
|
324 return num - 1;
|
|
|
325 /* Buckets 16 - NUM_VOP_FREE_BUCKETS represent 8 unit chunks. */
|
|
|
326 num = 14 + (num - 1) / 8;
|
|
|
327 if (num >= NUM_VOP_FREE_BUCKETS)
|
|
|
328 return -1;
|
|
|
329 else
|
|
|
330 return num;
|
|
|
331 }
|
|
|
332
|
|
|
333
|
|
|
334 /* Initialize the VOP free buckets. */
|
|
|
335
|
|
|
336 static inline void
|
|
|
337 init_vop_buckets (void)
|
|
|
338 {
|
|
|
339 int x;
|
|
|
340
|
|
|
341 for (x = 0; x < NUM_VOP_FREE_BUCKETS; x++)
|
|
|
342 gimple_ssa_operands (cfun)->vop_free_buckets[x] = NULL;
|
|
|
343 }
|
|
|
344
|
|
|
345
|
|
|
346 /* Add PTR to the appropriate VOP bucket. */
|
|
|
347
|
|
|
348 static inline void
|
|
|
349 add_vop_to_freelist (voptype_p ptr)
|
|
|
350 {
|
|
|
351 int bucket = vop_free_bucket_index (VUSE_VECT_NUM_ELEM (ptr->usev));
|
|
|
352
|
|
|
353 /* Too large, use the largest bucket so its not a complete throw away. */
|
|
|
354 if (bucket == -1)
|
|
|
355 bucket = NUM_VOP_FREE_BUCKETS - 1;
|
|
|
356
|
|
|
357 ptr->next = gimple_ssa_operands (cfun)->vop_free_buckets[bucket];
|
|
|
358 gimple_ssa_operands (cfun)->vop_free_buckets[bucket] = ptr;
|
|
|
359 }
|
|
|
360
|
|
|
361
|
|
|
362 /* These are the sizes of the operand memory buffer which gets allocated each
|
|
|
363 time more operands space is required. The final value is the amount that is
|
|
|
364 allocated every time after that. */
|
|
|
365
|
|
|
366 #define OP_SIZE_INIT 0
|
|
|
367 #define OP_SIZE_1 30
|
|
|
368 #define OP_SIZE_2 110
|
|
|
369 #define OP_SIZE_3 511
|
|
|
370
|
|
|
371 /* Initialize the operand cache routines. */
|
|
|
372
|
|
|
373 void
|
|
|
374 init_ssa_operands (void)
|
|
|
375 {
|
|
|
376 if (!n_initialized++)
|
|
|
377 {
|
|
|
378 build_defs = VEC_alloc (tree, heap, 5);
|
|
|
379 build_uses = VEC_alloc (tree, heap, 10);
|
|
|
380 build_vuses = VEC_alloc (tree, heap, 25);
|
|
|
381 build_vdefs = VEC_alloc (tree, heap, 25);
|
|
|
382 bitmap_obstack_initialize (&operands_bitmap_obstack);
|
|
|
383 build_loads = BITMAP_ALLOC (&operands_bitmap_obstack);
|
|
|
384 build_stores = BITMAP_ALLOC (&operands_bitmap_obstack);
|
|
|
385 scb_stack = VEC_alloc (scb_t, heap, 20);
|
|
|
386 }
|
|
|
387
|
|
|
388 gcc_assert (gimple_ssa_operands (cfun)->operand_memory == NULL);
|
|
|
389 gcc_assert (gimple_ssa_operands (cfun)->mpt_table == NULL);
|
|
|
390 gimple_ssa_operands (cfun)->operand_memory_index
|
|
|
391 = gimple_ssa_operands (cfun)->ssa_operand_mem_size;
|
|
|
392 gimple_ssa_operands (cfun)->ops_active = true;
|
|
|
393 memset (&clobber_stats, 0, sizeof (clobber_stats));
|
|
|
394 init_vop_buckets ();
|
|
|
395 gimple_ssa_operands (cfun)->ssa_operand_mem_size = OP_SIZE_INIT;
|
|
|
396 }
|
|
|
397
|
|
|
398
|
|
|
399 /* Dispose of anything required by the operand routines. */
|
|
|
400
|
|
|
401 void
|
|
|
402 fini_ssa_operands (void)
|
|
|
403 {
|
|
|
404 struct ssa_operand_memory_d *ptr;
|
|
|
405 unsigned ix;
|
|
|
406 tree mpt;
|
|
|
407
|
|
|
408 if (!--n_initialized)
|
|
|
409 {
|
|
|
410 VEC_free (tree, heap, build_defs);
|
|
|
411 VEC_free (tree, heap, build_uses);
|
|
|
412 VEC_free (tree, heap, build_vdefs);
|
|
|
413 VEC_free (tree, heap, build_vuses);
|
|
|
414 BITMAP_FREE (build_loads);
|
|
|
415 BITMAP_FREE (build_stores);
|
|
|
416
|
|
|
417 /* The change buffer stack had better be empty. */
|
|
|
418 gcc_assert (VEC_length (scb_t, scb_stack) == 0);
|
|
|
419 VEC_free (scb_t, heap, scb_stack);
|
|
|
420 scb_stack = NULL;
|
|
|
421 }
|
|
|
422
|
|
|
423 gimple_ssa_operands (cfun)->free_defs = NULL;
|
|
|
424 gimple_ssa_operands (cfun)->free_uses = NULL;
|
|
|
425
|
|
|
426 while ((ptr = gimple_ssa_operands (cfun)->operand_memory) != NULL)
|
|
|
427 {
|
|
|
428 gimple_ssa_operands (cfun)->operand_memory
|
|
|
429 = gimple_ssa_operands (cfun)->operand_memory->next;
|
|
|
430 ggc_free (ptr);
|
|
|
431 }
|
|
|
432
|
|
|
433 for (ix = 0;
|
|
|
434 VEC_iterate (tree, gimple_ssa_operands (cfun)->mpt_table, ix, mpt);
|
|
|
435 ix++)
|
|
|
436 {
|
|
|
437 if (mpt)
|
|
|
438 BITMAP_FREE (MPT_SYMBOLS (mpt));
|
|
|
439 }
|
|
|
440
|
|
|
441 VEC_free (tree, heap, gimple_ssa_operands (cfun)->mpt_table);
|
|
|
442
|
|
|
443 gimple_ssa_operands (cfun)->ops_active = false;
|
|
|
444
|
|
|
445 if (!n_initialized)
|
|
|
446 bitmap_obstack_release (&operands_bitmap_obstack);
|
|
|
447
|
|
|
448 if (dump_file && (dump_flags & TDF_STATS))
|
|
|
449 {
|
|
|
450 fprintf (dump_file, "Original clobbered vars: %d\n",
|
|
|
451 clobber_stats.clobbered_vars);
|
|
|
452 fprintf (dump_file, "Static write clobbers avoided: %d\n",
|
|
|
453 clobber_stats.static_write_clobbers_avoided);
|
|
|
454 fprintf (dump_file, "Static read clobbers avoided: %d\n",
|
|
|
455 clobber_stats.static_read_clobbers_avoided);
|
|
|
456 fprintf (dump_file, "Unescapable clobbers avoided: %d\n",
|
|
|
457 clobber_stats.unescapable_clobbers_avoided);
|
|
|
458 fprintf (dump_file, "Original read-only clobbers: %d\n",
|
|
|
459 clobber_stats.readonly_clobbers);
|
|
|
460 fprintf (dump_file, "Static read-only clobbers avoided: %d\n",
|
|
|
461 clobber_stats.static_readonly_clobbers_avoided);
|
|
|
462 }
|
|
|
463 }
|
|
|
464
|
|
|
465
|
|
|
466 /* Return memory for operands of SIZE chunks. */
|
|
|
467
|
|
|
468 static inline void *
|
|
|
469 ssa_operand_alloc (unsigned size)
|
|
|
470 {
|
|
|
471 char *ptr;
|
|
|
472
|
|
|
473 if (gimple_ssa_operands (cfun)->operand_memory_index + size
|
|
|
474 >= gimple_ssa_operands (cfun)->ssa_operand_mem_size)
|
|
|
475 {
|
|
|
476 struct ssa_operand_memory_d *ptr;
|
|
|
477
|
|
|
478 if (gimple_ssa_operands (cfun)->ssa_operand_mem_size == OP_SIZE_INIT)
|
|
|
479 gimple_ssa_operands (cfun)->ssa_operand_mem_size
|
|
|
480 = OP_SIZE_1 * sizeof (struct voptype_d);
|
|
|
481 else
|
|
|
482 if (gimple_ssa_operands (cfun)->ssa_operand_mem_size
|
|
|
483 == OP_SIZE_1 * sizeof (struct voptype_d))
|
|
|
484 gimple_ssa_operands (cfun)->ssa_operand_mem_size
|
|
|
485 = OP_SIZE_2 * sizeof (struct voptype_d);
|
|
|
486 else
|
|
|
487 gimple_ssa_operands (cfun)->ssa_operand_mem_size
|
|
|
488 = OP_SIZE_3 * sizeof (struct voptype_d);
|
|
|
489
|
|
|
490 /* Go right to the maximum size if the request is too large. */
|
|
|
491 if (size > gimple_ssa_operands (cfun)->ssa_operand_mem_size)
|
|
|
492 gimple_ssa_operands (cfun)->ssa_operand_mem_size
|
|
|
493 = OP_SIZE_3 * sizeof (struct voptype_d);
|
|
|
494
|
|
|
495 /* We can reliably trigger the case that we need arbitrary many
|
|
|
496 operands (see PR34093), so allocate a buffer just for this request. */
|
|
|
497 if (size > gimple_ssa_operands (cfun)->ssa_operand_mem_size)
|
|
|
498 gimple_ssa_operands (cfun)->ssa_operand_mem_size = size;
|
|
|
499
|
|
|
500 ptr = (struct ssa_operand_memory_d *)
|
|
|
501 ggc_alloc (sizeof (struct ssa_operand_memory_d)
|
|
|
502 + gimple_ssa_operands (cfun)->ssa_operand_mem_size - 1);
|
|
|
503 ptr->next = gimple_ssa_operands (cfun)->operand_memory;
|
|
|
504 gimple_ssa_operands (cfun)->operand_memory = ptr;
|
|
|
505 gimple_ssa_operands (cfun)->operand_memory_index = 0;
|
|
|
506 }
|
|
|
507 ptr = &(gimple_ssa_operands (cfun)->operand_memory
|
|
|
508 ->mem[gimple_ssa_operands (cfun)->operand_memory_index]);
|
|
|
509 gimple_ssa_operands (cfun)->operand_memory_index += size;
|
|
|
510 return ptr;
|
|
|
511 }
|
|
|
512
|
|
|
513
|
|
|
514 /* Allocate a DEF operand. */
|
|
|
515
|
|
|
516 static inline struct def_optype_d *
|
|
|
517 alloc_def (void)
|
|
|
518 {
|
|
|
519 struct def_optype_d *ret;
|
|
|
520 if (gimple_ssa_operands (cfun)->free_defs)
|
|
|
521 {
|
|
|
522 ret = gimple_ssa_operands (cfun)->free_defs;
|
|
|
523 gimple_ssa_operands (cfun)->free_defs
|
|
|
524 = gimple_ssa_operands (cfun)->free_defs->next;
|
|
|
525 }
|
|
|
526 else
|
|
|
527 ret = (struct def_optype_d *)
|
|
|
528 ssa_operand_alloc (sizeof (struct def_optype_d));
|
|
|
529 return ret;
|
|
|
530 }
|
|
|
531
|
|
|
532
|
|
|
533 /* Allocate a USE operand. */
|
|
|
534
|
|
|
535 static inline struct use_optype_d *
|
|
|
536 alloc_use (void)
|
|
|
537 {
|
|
|
538 struct use_optype_d *ret;
|
|
|
539 if (gimple_ssa_operands (cfun)->free_uses)
|
|
|
540 {
|
|
|
541 ret = gimple_ssa_operands (cfun)->free_uses;
|
|
|
542 gimple_ssa_operands (cfun)->free_uses
|
|
|
543 = gimple_ssa_operands (cfun)->free_uses->next;
|
|
|
544 }
|
|
|
545 else
|
|
|
546 ret = (struct use_optype_d *)
|
|
|
547 ssa_operand_alloc (sizeof (struct use_optype_d));
|
|
|
548 return ret;
|
|
|
549 }
|
|
|
550
|
|
|
551
|
|
|
552 /* Allocate a vop with NUM elements. */
|
|
|
553
|
|
|
554 static inline struct voptype_d *
|
|
|
555 alloc_vop (int num)
|
|
|
556 {
|
|
|
557 struct voptype_d *ret = NULL;
|
|
|
558 int alloc_size = 0;
|
|
|
559
|
|
|
560 int bucket = vop_free_bucket_index (num);
|
|
|
561 if (bucket != -1)
|
|
|
562 {
|
|
|
563 /* If there is a free operand, use it. */
|
|
|
564 if (gimple_ssa_operands (cfun)->vop_free_buckets[bucket] != NULL)
|
|
|
565 {
|
|
|
566 ret = gimple_ssa_operands (cfun)->vop_free_buckets[bucket];
|
|
|
567 gimple_ssa_operands (cfun)->vop_free_buckets[bucket] =
|
|
|
568 gimple_ssa_operands (cfun)->vop_free_buckets[bucket]->next;
|
|
|
569 }
|
|
|
570 else
|
|
|
571 alloc_size = vop_free_bucket_size(bucket);
|
|
|
572 }
|
|
|
573 else
|
|
|
574 alloc_size = num;
|
|
|
575
|
|
|
576 if (alloc_size > 0)
|
|
|
577 ret = (struct voptype_d *)ssa_operand_alloc (
|
|
|
578 sizeof (struct voptype_d) + (alloc_size - 1) * sizeof (vuse_element_t));
|
|
|
579
|
|
|
580 VUSE_VECT_NUM_ELEM (ret->usev) = num;
|
|
|
581 return ret;
|
|
|
582 }
|
|
|
583
|
|
|
584
|
|
|
585 /* This routine makes sure that PTR is in an immediate use list, and makes
|
|
|
586 sure the stmt pointer is set to the current stmt. */
|
|
|
587
|
|
|
588 static inline void
|
|
|
589 set_virtual_use_link (use_operand_p ptr, gimple stmt)
|
|
|
590 {
|
|
|
591 /* fold_stmt may have changed the stmt pointers. */
|
|
|
592 if (ptr->loc.stmt != stmt)
|
|
|
593 ptr->loc.stmt = stmt;
|
|
|
594
|
|
|
595 /* If this use isn't in a list, add it to the correct list. */
|
|
|
596 if (!ptr->prev)
|
|
|
597 link_imm_use (ptr, *(ptr->use));
|
|
|
598 }
|
|
|
599
|
|
|
600
|
|
|
601 /* Adds OP to the list of defs after LAST. */
|
|
|
602
|
|
|
603 static inline def_optype_p
|
|
|
604 add_def_op (tree *op, def_optype_p last)
|
|
|
605 {
|
|
|
606 def_optype_p new_def;
|
|
|
607
|
|
|
608 new_def = alloc_def ();
|
|
|
609 DEF_OP_PTR (new_def) = op;
|
|
|
610 last->next = new_def;
|
|
|
611 new_def->next = NULL;
|
|
|
612 return new_def;
|
|
|
613 }
|
|
|
614
|
|
|
615
|
|
|
616 /* Adds OP to the list of uses of statement STMT after LAST. */
|
|
|
617
|
|
|
618 static inline use_optype_p
|
|
|
619 add_use_op (gimple stmt, tree *op, use_optype_p last)
|
|
|
620 {
|
|
|
621 use_optype_p new_use;
|
|
|
622
|
|
|
623 new_use = alloc_use ();
|
|
|
624 USE_OP_PTR (new_use)->use = op;
|
|
|
625 link_imm_use_stmt (USE_OP_PTR (new_use), *op, stmt);
|
|
|
626 last->next = new_use;
|
|
|
627 new_use->next = NULL;
|
|
|
628 return new_use;
|
|
|
629 }
|
|
|
630
|
|
|
631
|
|
|
632 /* Return a virtual op pointer with NUM elements which are all
|
|
|
633 initialized to OP and are linked into the immediate uses for STMT.
|
|
|
634 The new vop is appended after PREV. */
|
|
|
635
|
|
|
636 static inline voptype_p
|
|
|
637 add_vop (gimple stmt, tree op, int num, voptype_p prev)
|
|
|
638 {
|
|
|
639 voptype_p new_vop;
|
|
|
640 int x;
|
|
|
641
|
|
|
642 new_vop = alloc_vop (num);
|
|
|
643 for (x = 0; x < num; x++)
|
|
|
644 {
|
|
|
645 VUSE_OP_PTR (new_vop, x)->prev = NULL;
|
|
|
646 SET_VUSE_OP (new_vop, x, op);
|
|
|
647 VUSE_OP_PTR (new_vop, x)->use = &new_vop->usev.uses[x].use_var;
|
|
|
648 link_imm_use_stmt (VUSE_OP_PTR (new_vop, x),
|
|
|
649 new_vop->usev.uses[x].use_var, stmt);
|
|
|
650 }
|
|
|
651
|
|
|
652 if (prev)
|
|
|
653 prev->next = new_vop;
|
|
|
654 new_vop->next = NULL;
|
|
|
655 return new_vop;
|
|
|
656 }
|
|
|
657
|
|
|
658
|
|
|
659 /* Adds OP to the list of vuses of statement STMT after LAST, and moves
|
|
|
660 LAST to the new element. */
|
|
|
661
|
|
|
662 static inline voptype_p
|
|
|
663 add_vuse_op (gimple stmt, tree op, int num, voptype_p last)
|
|
|
664 {
|
|
|
665 voptype_p new_vop = add_vop (stmt, op, num, last);
|
|
|
666 VDEF_RESULT (new_vop) = NULL_TREE;
|
|
|
667 return new_vop;
|
|
|
668 }
|
|
|
669
|
|
|
670
|
|
|
671 /* Adds OP to the list of vdefs of statement STMT after LAST, and moves
|
|
|
672 LAST to the new element. */
|
|
|
673
|
|
|
674 static inline voptype_p
|
|
|
675 add_vdef_op (gimple stmt, tree op, int num, voptype_p last)
|
|
|
676 {
|
|
|
677 voptype_p new_vop = add_vop (stmt, op, num, last);
|
|
|
678 VDEF_RESULT (new_vop) = op;
|
|
|
679 return new_vop;
|
|
|
680 }
|
|
|
681
|
|
|
682
|
|
|
683 /* Takes elements from build_defs and turns them into def operands of STMT.
|
|
|
684 TODO -- Make build_defs VEC of tree *. */
|
|
|
685
|
|
|
686 static inline void
|
|
|
687 finalize_ssa_defs (gimple stmt)
|
|
|
688 {
|
|
|
689 unsigned new_i;
|
|
|
690 struct def_optype_d new_list;
|
|
|
691 def_optype_p old_ops, last;
|
|
|
692 unsigned int num = VEC_length (tree, build_defs);
|
|
|
693
|
|
|
694 /* There should only be a single real definition per assignment. */
|
|
|
695 gcc_assert ((stmt && gimple_code (stmt) != GIMPLE_ASSIGN) || num <= 1);
|
|
|
696
|
|
|
697 new_list.next = NULL;
|
|
|
698 last = &new_list;
|
|
|
699
|
|
|
700 old_ops = gimple_def_ops (stmt);
|
|
|
701
|
|
|
702 new_i = 0;
|
|
|
703
|
|
|
704 /* Check for the common case of 1 def that hasn't changed. */
|
|
|
705 if (old_ops && old_ops->next == NULL && num == 1
|
|
|
706 && (tree *) VEC_index (tree, build_defs, 0) == DEF_OP_PTR (old_ops))
|
|
|
707 return;
|
|
|
708
|
|
|
709 /* If there is anything in the old list, free it. */
|
|
|
710 if (old_ops)
|
|
|
711 {
|
|
|
712 old_ops->next = gimple_ssa_operands (cfun)->free_defs;
|
|
|
713 gimple_ssa_operands (cfun)->free_defs = old_ops;
|
|
|
714 }
|
|
|
715
|
|
|
716 /* If there is anything remaining in the build_defs list, simply emit it. */
|
|
|
717 for ( ; new_i < num; new_i++)
|
|
|
718 last = add_def_op ((tree *) VEC_index (tree, build_defs, new_i), last);
|
|
|
719
|
|
|
720 /* Now set the stmt's operands. */
|
|
|
721 gimple_set_def_ops (stmt, new_list.next);
|
|
|
722
|
|
|
723 #ifdef ENABLE_CHECKING
|
|
|
724 {
|
|
|
725 def_optype_p ptr;
|
|
|
726 unsigned x = 0;
|
|
|
727 for (ptr = gimple_def_ops (stmt); ptr; ptr = ptr->next)
|
|
|
728 x++;
|
|
|
729
|
|
|
730 gcc_assert (x == num);
|
|
|
731 }
|
|
|
732 #endif
|
|
|
733 }
|
|
|
734
|
|
|
735
|
|
|
736 /* Takes elements from build_uses and turns them into use operands of STMT.
|
|
|
737 TODO -- Make build_uses VEC of tree *. */
|
|
|
738
|
|
|
739 static inline void
|
|
|
740 finalize_ssa_uses (gimple stmt)
|
|
|
741 {
|
|
|
742 unsigned new_i;
|
|
|
743 struct use_optype_d new_list;
|
|
|
744 use_optype_p old_ops, ptr, last;
|
|
|
745
|
|
|
746 new_list.next = NULL;
|
|
|
747 last = &new_list;
|
|
|
748
|
|
|
749 old_ops = gimple_use_ops (stmt);
|
|
|
750
|
|
|
751 /* If there is anything in the old list, free it. */
|
|
|
752 if (old_ops)
|
|
|
753 {
|
|
|
754 for (ptr = old_ops; ptr; ptr = ptr->next)
|
|
|
755 delink_imm_use (USE_OP_PTR (ptr));
|
|
|
756 old_ops->next = gimple_ssa_operands (cfun)->free_uses;
|
|
|
757 gimple_ssa_operands (cfun)->free_uses = old_ops;
|
|
|
758 }
|
|
|
759
|
|
|
760 /* Now create nodes for all the new nodes. */
|
|
|
761 for (new_i = 0; new_i < VEC_length (tree, build_uses); new_i++)
|
|
|
762 last = add_use_op (stmt,
|
|
|
763 (tree *) VEC_index (tree, build_uses, new_i),
|
|
|
764 last);
|
|
|
765
|
|
|
766 /* Now set the stmt's operands. */
|
|
|
767 gimple_set_use_ops (stmt, new_list.next);
|
|
|
768
|
|
|
769 #ifdef ENABLE_CHECKING
|
|
|
770 {
|
|
|
771 unsigned x = 0;
|
|
|
772 for (ptr = gimple_use_ops (stmt); ptr; ptr = ptr->next)
|
|
|
773 x++;
|
|
|
774
|
|
|
775 gcc_assert (x == VEC_length (tree, build_uses));
|
|
|
776 }
|
|
|
777 #endif
|
|
|
778 }
|
|
|
779
|
|
|
780
|
|
|
781 /* Takes elements from BUILD_VDEFS and turns them into vdef operands of
|
|
|
782 STMT. */
|
|
|
783
|
|
|
784 static inline void
|
|
|
785 finalize_ssa_vdefs (gimple stmt)
|
|
|
786 {
|
|
|
787 unsigned new_i;
|
|
|
788 struct voptype_d new_list;
|
|
|
789 voptype_p old_ops, ptr, last;
|
|
|
790
|
|
|
791 /* Set the symbols referenced by STMT. */
|
|
|
792 gimple_set_stored_syms (stmt, build_stores, &operands_bitmap_obstack);
|
|
|
793
|
|
|
794 /* If aliases have not been computed, do not instantiate a virtual
|
|
|
795 operator on STMT. Initially, we only compute the SSA form on
|
|
|
796 GIMPLE registers. The virtual SSA form is only computed after
|
|
|
797 alias analysis, so virtual operators will remain unrenamed and
|
|
|
798 the verifier will complain. However, alias analysis needs to
|
|
|
799 access symbol load/store information, so we need to compute
|
|
|
800 those. */
|
|
|
801 if (!gimple_aliases_computed_p (cfun))
|
|
|
802 return;
|
|
|
803
|
|
|
804 new_list.next = NULL;
|
|
|
805 last = &new_list;
|
|
|
806
|
|
|
807 old_ops = gimple_vdef_ops (stmt);
|
|
|
808 new_i = 0;
|
|
|
809 while (old_ops && new_i < VEC_length (tree, build_vdefs))
|
|
|
810 {
|
|
|
811 tree op = VEC_index (tree, build_vdefs, new_i);
|
|
|
812 unsigned new_uid = get_name_decl (op);
|
|
|
813 unsigned old_uid = get_name_decl (VDEF_RESULT (old_ops));
|
|
|
814
|
|
|
815 /* FIXME, for now each VDEF operator should have at most one
|
|
|
816 operand in their RHS. */
|
|
|
817 gcc_assert (VDEF_NUM (old_ops) == 1);
|
|
|
818
|
|
|
819 if (old_uid == new_uid)
|
|
|
820 {
|
|
|
821 /* If the symbols are the same, reuse the existing operand. */
|
|
|
822 last->next = old_ops;
|
|
|
823 last = old_ops;
|
|
|
824 old_ops = old_ops->next;
|
|
|
825 last->next = NULL;
|
|
|
826 set_virtual_use_link (VDEF_OP_PTR (last, 0), stmt);
|
|
|
827 new_i++;
|
|
|
828 }
|
|
|
829 else if (old_uid < new_uid)
|
|
|
830 {
|
|
|
831 /* If old is less than new, old goes to the free list. */
|
|
|
832 voptype_p next;
|
|
|
833 delink_imm_use (VDEF_OP_PTR (old_ops, 0));
|
|
|
834 next = old_ops->next;
|
|
|
835 add_vop_to_freelist (old_ops);
|
|
|
836 old_ops = next;
|
|
|
837 }
|
|
|
838 else
|
|
|
839 {
|
|
|
840 /* This is a new operand. */
|
|
|
841 last = add_vdef_op (stmt, op, 1, last);
|
|
|
842 new_i++;
|
|
|
843 }
|
|
|
844 }
|
|
|
845
|
|
|
846 /* If there is anything remaining in BUILD_VDEFS, simply emit it. */
|
|
|
847 for ( ; new_i < VEC_length (tree, build_vdefs); new_i++)
|
|
|
848 last = add_vdef_op (stmt, VEC_index (tree, build_vdefs, new_i), 1, last);
|
|
|
849
|
|
|
850 /* If there is anything in the old list, free it. */
|
|
|
851 if (old_ops)
|
|
|
852 {
|
|
|
853 for (ptr = old_ops; ptr; ptr = last)
|
|
|
854 {
|
|
|
855 last = ptr->next;
|
|
|
856 delink_imm_use (VDEF_OP_PTR (ptr, 0));
|
|
|
857 add_vop_to_freelist (ptr);
|
|
|
858 }
|
|
|
859 }
|
|
|
860
|
|
|
861 /* Now set STMT's operands. */
|
|
|
862 gimple_set_vdef_ops (stmt, new_list.next);
|
|
|
863
|
|
|
864 #ifdef ENABLE_CHECKING
|
|
|
865 {
|
|
|
866 unsigned x = 0;
|
|
|
867 for (ptr = gimple_vdef_ops (stmt); ptr; ptr = ptr->next)
|
|
|
868 x++;
|
|
|
869
|
|
|
870 gcc_assert (x == VEC_length (tree, build_vdefs));
|
|
|
871 }
|
|
|
872 #endif
|
|
|
873 }
|
|
|
874
|
|
|
875
|
|
|
876 /* Takes elements from BUILD_VUSES and turns them into VUSE operands of
|
|
|
877 STMT. */
|
|
|
878
|
|
|
879 static inline void
|
|
|
880 finalize_ssa_vuse_ops (gimple stmt)
|
|
|
881 {
|
|
|
882 unsigned new_i, old_i;
|
|
|
883 voptype_p old_ops, last;
|
|
|
884 VEC(tree,heap) *new_ops;
|
|
|
885
|
|
|
886 /* Set the symbols referenced by STMT. */
|
|
|
887 gimple_set_loaded_syms (stmt, build_loads, &operands_bitmap_obstack);
|
|
|
888
|
|
|
889 /* If aliases have not been computed, do not instantiate a virtual
|
|
|
890 operator on STMT. Initially, we only compute the SSA form on
|
|
|
891 GIMPLE registers. The virtual SSA form is only computed after
|
|
|
892 alias analysis, so virtual operators will remain unrenamed and
|
|
|
893 the verifier will complain. However, alias analysis needs to
|
|
|
894 access symbol load/store information, so we need to compute
|
|
|
895 those. */
|
|
|
896 if (!gimple_aliases_computed_p (cfun))
|
|
|
897 return;
|
|
|
898
|
|
|
899 /* STMT should have at most one VUSE operator. */
|
|
|
900 old_ops = gimple_vuse_ops (stmt);
|
|
|
901 gcc_assert (old_ops == NULL || old_ops->next == NULL);
|
|
|
902
|
|
|
903 new_ops = NULL;
|
|
|
904 new_i = old_i = 0;
|
|
|
905 while (old_ops
|
|
|
906 && old_i < VUSE_NUM (old_ops)
|
|
|
907 && new_i < VEC_length (tree, build_vuses))
|
|
|
908 {
|
|
|
909 tree new_op = VEC_index (tree, build_vuses, new_i);
|
|
|
910 tree old_op = VUSE_OP (old_ops, old_i);
|
|
|
911 unsigned new_uid = get_name_decl (new_op);
|
|
|
912 unsigned old_uid = get_name_decl (old_op);
|
|
|
913
|
|
|
914 if (old_uid == new_uid)
|
|
|
915 {
|
|
|
916 /* If the symbols are the same, reuse the existing operand. */
|
|
|
917 VEC_safe_push (tree, heap, new_ops, old_op);
|
|
|
918 new_i++;
|
|
|
919 old_i++;
|
|
|
920 }
|
|
|
921 else if (old_uid < new_uid)
|
|
|
922 {
|
|
|
923 /* If OLD_UID is less than NEW_UID, the old operand has
|
|
|
924 disappeared, skip to the next old operand. */
|
|
|
925 old_i++;
|
|
|
926 }
|
|
|
927 else
|
|
|
928 {
|
|
|
929 /* This is a new operand. */
|
|
|
930 VEC_safe_push (tree, heap, new_ops, new_op);
|
|
|
931 new_i++;
|
|
|
932 }
|
|
|
933 }
|
|
|
934
|
|
|
935 /* If there is anything remaining in the build_vuses list, simply emit it. */
|
|
|
936 for ( ; new_i < VEC_length (tree, build_vuses); new_i++)
|
|
|
937 VEC_safe_push (tree, heap, new_ops, VEC_index (tree, build_vuses, new_i));
|
|
|
938
|
|
|
939 /* If there is anything in the old list, free it. */
|
|
|
940 if (old_ops)
|
|
|
941 {
|
|
|
942 for (old_i = 0; old_i < VUSE_NUM (old_ops); old_i++)
|
|
|
943 delink_imm_use (VUSE_OP_PTR (old_ops, old_i));
|
|
|
944 add_vop_to_freelist (old_ops);
|
|
|
945 gimple_set_vuse_ops (stmt, NULL);
|
|
|
946 }
|
|
|
947
|
|
|
948 /* If there are any operands, instantiate a VUSE operator for STMT. */
|
|
|
949 if (new_ops)
|
|
|
950 {
|
|
|
951 tree op;
|
|
|
952 unsigned i;
|
|
|
953
|
|
|
954 last = add_vuse_op (stmt, NULL, VEC_length (tree, new_ops), NULL);
|
|
|
955
|
|
|
956 for (i = 0; VEC_iterate (tree, new_ops, i, op); i++)
|
|
|
957 SET_USE (VUSE_OP_PTR (last, (int) i), op);
|
|
|
958
|
|
|
959 gimple_set_vuse_ops (stmt, last);
|
|
|
960 VEC_free (tree, heap, new_ops);
|
|
|
961 }
|
|
|
962
|
|
|
963 #ifdef ENABLE_CHECKING
|
|
|
964 {
|
|
|
965 unsigned x;
|
|
|
966
|
|
|
967 if (gimple_vuse_ops (stmt))
|
|
|
968 {
|
|
|
969 gcc_assert (gimple_vuse_ops (stmt)->next == NULL);
|
|
|
970 x = VUSE_NUM (gimple_vuse_ops (stmt));
|
|
|
971 }
|
|
|
972 else
|
|
|
973 x = 0;
|
|
|
974
|
|
|
975 gcc_assert (x == VEC_length (tree, build_vuses));
|
|
|
976 }
|
|
|
977 #endif
|
|
|
978 }
|
|
|
979
|
|
|
980 /* Return a new VUSE operand vector for STMT. */
|
|
|
981
|
|
|
982 static void
|
|
|
983 finalize_ssa_vuses (gimple stmt)
|
|
|
984 {
|
|
|
985 unsigned num, num_vdefs;
|
|
|
986 unsigned vuse_index;
|
|
|
987
|
|
|
988 /* Remove superfluous VUSE operands. If the statement already has a
|
|
|
989 VDEF operator for a variable 'a', then a VUSE for 'a' is not
|
|
|
990 needed because VDEFs imply a VUSE of the variable. For instance,
|
|
|
991 suppose that variable 'a' is pointed-to by p and q:
|
|
|
992
|
|
|
993 # VUSE <a_2>
|
|
|
994 # a_3 = VDEF <a_2>
|
|
|
995 *p = *q;
|
|
|
996
|
|
|
997 The VUSE <a_2> is superfluous because it is implied by the
|
|
|
998 VDEF operator. */
|
|
|
999 num = VEC_length (tree, build_vuses);
|
|
|
1000 num_vdefs = VEC_length (tree, build_vdefs);
|
|
|
1001
|
|
|
1002 if (num > 0 && num_vdefs > 0)
|
|
|
1003 for (vuse_index = 0; vuse_index < VEC_length (tree, build_vuses); )
|
|
|
1004 {
|
|
|
1005 tree vuse;
|
|
|
1006 vuse = VEC_index (tree, build_vuses, vuse_index);
|
|
|
1007 if (TREE_CODE (vuse) != SSA_NAME)
|
|
|
1008 {
|
|
|
1009 var_ann_t ann = var_ann (vuse);
|
|
|
1010 ann->in_vuse_list = 0;
|
|
|
1011 if (ann->in_vdef_list)
|
|
|
1012 {
|
|
|
1013 VEC_ordered_remove (tree, build_vuses, vuse_index);
|
|
|
1014 continue;
|
|
|
1015 }
|
|
|
1016 }
|
|
|
1017 vuse_index++;
|
|
|
1018 }
|
|
|
1019
|
|
|
1020 finalize_ssa_vuse_ops (stmt);
|
|
|
1021 }
|
|
|
1022
|
|
|
1023
|
|
|
1024 /* Clear the in_list bits and empty the build array for VDEFs and
|
|
|
1025 VUSEs. */
|
|
|
1026
|
|
|
1027 static inline void
|
|
|
1028 cleanup_build_arrays (void)
|
|
|
1029 {
|
|
|
1030 unsigned i;
|
|
|
1031 tree t;
|
|
|
1032
|
|
|
1033 for (i = 0; VEC_iterate (tree, build_vdefs, i, t); i++)
|
|
|
1034 if (TREE_CODE (t) != SSA_NAME)
|
|
|
1035 var_ann (t)->in_vdef_list = false;
|
|
|
1036
|
|
|
1037 for (i = 0; VEC_iterate (tree, build_vuses, i, t); i++)
|
|
|
1038 if (TREE_CODE (t) != SSA_NAME)
|
|
|
1039 var_ann (t)->in_vuse_list = false;
|
|
|
1040
|
|
|
1041 VEC_truncate (tree, build_vdefs, 0);
|
|
|
1042 VEC_truncate (tree, build_vuses, 0);
|
|
|
1043 VEC_truncate (tree, build_defs, 0);
|
|
|
1044 VEC_truncate (tree, build_uses, 0);
|
|
|
1045 bitmap_clear (build_loads);
|
|
|
1046 bitmap_clear (build_stores);
|
|
|
1047 }
|
|
|
1048
|
|
|
1049
|
|
|
1050 /* Finalize all the build vectors, fill the new ones into INFO. */
|
|
|
1051
|
|
|
1052 static inline void
|
|
|
1053 finalize_ssa_stmt_operands (gimple stmt)
|
|
|
1054 {
|
|
|
1055 finalize_ssa_defs (stmt);
|
|
|
1056 finalize_ssa_uses (stmt);
|
|
|
1057 if (gimple_has_mem_ops (stmt))
|
|
|
1058 {
|
|
|
1059 finalize_ssa_vdefs (stmt);
|
|
|
1060 finalize_ssa_vuses (stmt);
|
|
|
1061 }
|
|
|
1062 cleanup_build_arrays ();
|
|
|
1063 }
|
|
|
1064
|
|
|
1065
|
|
|
1066 /* Start the process of building up operands vectors in INFO. */
|
|
|
1067
|
|
|
1068 static inline void
|
|
|
1069 start_ssa_stmt_operands (void)
|
|
|
1070 {
|
|
|
1071 gcc_assert (VEC_length (tree, build_defs) == 0);
|
|
|
1072 gcc_assert (VEC_length (tree, build_uses) == 0);
|
|
|
1073 gcc_assert (VEC_length (tree, build_vuses) == 0);
|
|
|
1074 gcc_assert (VEC_length (tree, build_vdefs) == 0);
|
|
|
1075 gcc_assert (bitmap_empty_p (build_loads));
|
|
|
1076 gcc_assert (bitmap_empty_p (build_stores));
|
|
|
1077 }
|
|
|
1078
|
|
|
1079
|
|
|
1080 /* Add DEF_P to the list of pointers to operands. */
|
|
|
1081
|
|
|
1082 static inline void
|
|
|
1083 append_def (tree *def_p)
|
|
|
1084 {
|
|
|
1085 VEC_safe_push (tree, heap, build_defs, (tree) def_p);
|
|
|
1086 }
|
|
|
1087
|
|
|
1088
|
|
|
1089 /* Add USE_P to the list of pointers to operands. */
|
|
|
1090
|
|
|
1091 static inline void
|
|
|
1092 append_use (tree *use_p)
|
|
|
1093 {
|
|
|
1094 VEC_safe_push (tree, heap, build_uses, (tree) use_p);
|
|
|
1095 }
|
|
|
1096
|
|
|
1097
|
|
|
1098 /* Add VAR to the set of variables that require a VDEF operator. */
|
|
|
1099
|
|
|
1100 static inline void
|
|
|
1101 append_vdef (tree var)
|
|
|
1102 {
|
|
|
1103 tree sym;
|
|
|
1104
|
|
|
1105 if (TREE_CODE (var) != SSA_NAME)
|
|
|
1106 {
|
|
|
1107 tree mpt;
|
|
|
1108 var_ann_t ann;
|
|
|
1109
|
|
|
1110 /* If VAR belongs to a memory partition, use it instead of VAR. */
|
|
|
1111 mpt = memory_partition (var);
|
|
|
1112 if (mpt)
|
|
|
1113 var = mpt;
|
|
|
1114
|
|
|
1115 /* Don't allow duplicate entries. */
|
|
|
1116 ann = get_var_ann (var);
|
|
|
1117 if (ann->in_vdef_list)
|
|
|
1118 return;
|
|
|
1119
|
|
|
1120 ann->in_vdef_list = true;
|
|
|
1121 sym = var;
|
|
|
1122 }
|
|
|
1123 else
|
|
|
1124 sym = SSA_NAME_VAR (var);
|
|
|
1125
|
|
|
1126 VEC_safe_push (tree, heap, build_vdefs, var);
|
|
|
1127 bitmap_set_bit (build_stores, DECL_UID (sym));
|
|
|
1128 }
|
|
|
1129
|
|
|
1130
|
|
|
1131 /* Add VAR to the set of variables that require a VUSE operator. */
|
|
|
1132
|
|
|
1133 static inline void
|
|
|
1134 append_vuse (tree var)
|
|
|
1135 {
|
|
|
1136 tree sym;
|
|
|
1137
|
|
|
1138 if (TREE_CODE (var) != SSA_NAME)
|
|
|
1139 {
|
|
|
1140 tree mpt;
|
|
|
1141 var_ann_t ann;
|
|
|
1142
|
|
|
1143 /* If VAR belongs to a memory partition, use it instead of VAR. */
|
|
|
1144 mpt = memory_partition (var);
|
|
|
1145 if (mpt)
|
|
|
1146 var = mpt;
|
|
|
1147
|
|
|
1148 /* Don't allow duplicate entries. */
|
|
|
1149 ann = get_var_ann (var);
|
|
|
1150 if (ann->in_vuse_list)
|
|
|
1151 return;
|
|
|
1152 else if (ann->in_vdef_list)
|
|
|
1153 {
|
|
|
1154 /* We don't want a vuse if we already have a vdef, but we must
|
|
|
1155 still put this in build_loads. */
|
|
|
1156 bitmap_set_bit (build_loads, DECL_UID (var));
|
|
|
1157 return;
|
|
|
1158 }
|
|
|
1159
|
|
|
1160 ann->in_vuse_list = true;
|
|
|
1161 sym = var;
|
|
|
1162 }
|
|
|
1163 else
|
|
|
1164 sym = SSA_NAME_VAR (var);
|
|
|
1165
|
|
|
1166 VEC_safe_push (tree, heap, build_vuses, var);
|
|
|
1167 bitmap_set_bit (build_loads, DECL_UID (sym));
|
|
|
1168 }
|
|
|
1169
|
|
|
1170
|
|
|
1171 /* REF is a tree that contains the entire pointer dereference
|
|
|
1172 expression, if available, or NULL otherwise. ALIAS is the variable
|
|
|
1173 we are asking if REF can access. OFFSET and SIZE come from the
|
|
|
1174 memory access expression that generated this virtual operand.
|
|
|
1175
|
|
|
1176 XXX: We should handle the NO_ALIAS attributes here. */
|
|
|
1177
|
|
|
1178 static bool
|
|
|
1179 access_can_touch_variable (tree ref, tree alias, HOST_WIDE_INT offset,
|
|
|
1180 HOST_WIDE_INT size)
|
|
|
1181 {
|
|
|
1182 bool offsetgtz = offset > 0;
|
|
|
1183 unsigned HOST_WIDE_INT uoffset = (unsigned HOST_WIDE_INT) offset;
|
|
|
1184 tree base = ref ? get_base_address (ref) : NULL;
|
|
|
1185
|
|
|
1186 /* If ALIAS is .GLOBAL_VAR then the memory reference REF must be
|
|
|
1187 using a call-clobbered memory tag. By definition, call-clobbered
|
|
|
1188 memory tags can always touch .GLOBAL_VAR. */
|
|
|
1189 if (alias == gimple_global_var (cfun))
|
|
|
1190 return true;
|
|
|
1191
|
|
|
1192 /* If ref is a TARGET_MEM_REF, just return true, as we can't really
|
|
|
1193 disambiguate them right now. */
|
|
|
1194 if (ref && TREE_CODE (ref) == TARGET_MEM_REF)
|
|
|
1195 return true;
|
|
|
1196
|
|
|
1197 /* Without strict aliasing, it is impossible for a component access
|
|
|
1198 through a pointer to touch a random variable, unless that
|
|
|
1199 variable *is* a structure or a pointer.
|
|
|
1200
|
|
|
1201 That is, given p->c, and some random global variable b,
|
|
|
1202 there is no legal way that p->c could be an access to b.
|
|
|
1203
|
|
|
1204 Without strict aliasing on, we consider it legal to do something
|
|
|
1205 like:
|
|
|
1206
|
|
|
1207 struct foos { int l; };
|
|
|
1208 int foo;
|
|
|
1209 static struct foos *getfoo(void);
|
|
|
1210 int main (void)
|
|
|
1211 {
|
|
|
1212 struct foos *f = getfoo();
|
|
|
1213 f->l = 1;
|
|
|
1214 foo = 2;
|
|
|
1215 if (f->l == 1)
|
|
|
1216 abort();
|
|
|
1217 exit(0);
|
|
|
1218 }
|
|
|
1219 static struct foos *getfoo(void)
|
|
|
1220 { return (struct foos *)&foo; }
|
|
|
1221
|
|
|
1222 (taken from 20000623-1.c)
|
|
|
1223
|
|
|
1224 The docs also say/imply that access through union pointers
|
|
|
1225 is legal (but *not* if you take the address of the union member,
|
|
|
1226 i.e. the inverse), such that you can do
|
|
|
1227
|
|
|
1228 typedef union {
|
|
|
1229 int d;
|
|
|
1230 } U;
|
|
|
1231
|
|
|
1232 int rv;
|
|
|
1233 void breakme()
|
|
|
1234 {
|
|
|
1235 U *rv0;
|
|
|
1236 U *pretmp = (U*)&rv;
|
|
|
1237 rv0 = pretmp;
|
|
|
1238 rv0->d = 42;
|
|
|
1239 }
|
|
|
1240 To implement this, we just punt on accesses through union
|
|
|
1241 pointers entirely.
|
|
|
1242
|
|
|
1243 Another case we have to allow is accessing a variable
|
|
|
1244 through an array access at offset zero. This happens from
|
|
|
1245 code generated by the fortran frontend like
|
|
|
1246
|
|
|
1247 char[1:1] & my_char_ref;
|
|
|
1248 char my_char;
|
|
|
1249 my_char_ref_1 = (char[1:1] &) &my_char;
|
|
|
1250 D.874_2 = (*my_char_ref_1)[1]{lb: 1 sz: 1};
|
|
|
1251 */
|
|
|
1252 if (ref
|
|
|
1253 && flag_strict_aliasing
|
|
|
1254 && TREE_CODE (ref) != INDIRECT_REF
|
|
|
1255 && !MTAG_P (alias)
|
|
|
1256 && base
|
|
|
1257 && (TREE_CODE (base) != INDIRECT_REF
|
|
|
1258 || TREE_CODE (TREE_TYPE (base)) != UNION_TYPE)
|
|
|
1259 && (TREE_CODE (base) != INDIRECT_REF
|
|
|
1260 || TREE_CODE (ref) != ARRAY_REF
|
|
|
1261 || offset != 0
|
|
|
1262 || (DECL_SIZE (alias)
|
|
|
1263 && TREE_CODE (DECL_SIZE (alias)) == INTEGER_CST
|
|
|
1264 && size != -1
|
|
|
1265 && (unsigned HOST_WIDE_INT)size
|
|
|
1266 != TREE_INT_CST_LOW (DECL_SIZE (alias))))
|
|
|
1267 && !AGGREGATE_TYPE_P (TREE_TYPE (alias))
|
|
|
1268 && TREE_CODE (TREE_TYPE (alias)) != COMPLEX_TYPE
|
|
|
1269 && !var_ann (alias)->is_heapvar
|
|
|
1270 /* When the struct has may_alias attached to it, we need not to
|
|
|
1271 return true. */
|
|
|
1272 && get_alias_set (base))
|
|
|
1273 {
|
|
|
1274 #ifdef ACCESS_DEBUGGING
|
|
|
1275 fprintf (stderr, "Access to ");
|
|
|
1276 print_generic_expr (stderr, ref, 0);
|
|
|
1277 fprintf (stderr, " may not touch ");
|
|
|
1278 print_generic_expr (stderr, alias, 0);
|
|
|
1279 fprintf (stderr, " in function %s\n", get_name (current_function_decl));
|
|
|
1280 #endif
|
|
|
1281 return false;
|
|
|
1282 }
|
|
|
1283
|
|
|
1284 /* If the offset of the access is greater than the size of one of
|
|
|
1285 the possible aliases, it can't be touching that alias, because it
|
|
|
1286 would be past the end of the structure. */
|
|
|
1287 else if (ref
|
|
|
1288 && flag_strict_aliasing
|
|
|
1289 && TREE_CODE (ref) != INDIRECT_REF
|
|
|
1290 && !MTAG_P (alias)
|
|
|
1291 && !var_ann (alias)->is_heapvar
|
|
|
1292 && !POINTER_TYPE_P (TREE_TYPE (alias))
|
|
|
1293 && offsetgtz
|
|
|
1294 && DECL_SIZE (alias)
|
|
|
1295 && TREE_CODE (DECL_SIZE (alias)) == INTEGER_CST
|
|
|
1296 && uoffset >= TREE_INT_CST_LOW (DECL_SIZE (alias)))
|
|
|
1297 {
|
|
|
1298 #ifdef ACCESS_DEBUGGING
|
|
|
1299 fprintf (stderr, "Access to ");
|
|
|
1300 print_generic_expr (stderr, ref, 0);
|
|
|
1301 fprintf (stderr, " may not touch ");
|
|
|
1302 print_generic_expr (stderr, alias, 0);
|
|
|
1303 fprintf (stderr, " in function %s\n", get_name (current_function_decl));
|
|
|
1304 #endif
|
|
|
1305 return false;
|
|
|
1306 }
|
|
|
1307
|
|
|
1308 return true;
|
|
|
1309 }
|
|
|
1310
|
|
|
1311 /* Add VAR to the virtual operands for STMT. FLAGS is as in
|
|
|
1312 get_expr_operands. FULL_REF is a tree that contains the entire
|
|
|
1313 pointer dereference expression, if available, or NULL otherwise.
|
|
|
1314 OFFSET and SIZE come from the memory access expression that
|
|
|
1315 generated this virtual operand. IS_CALL_SITE is true if the
|
|
|
1316 affected statement is a call site. */
|
|
|
1317
|
|
|
1318 static void
|
|
|
1319 add_virtual_operand (tree var, gimple stmt, int flags,
|
|
|
1320 tree full_ref, HOST_WIDE_INT offset,
|
|
|
1321 HOST_WIDE_INT size, bool is_call_site)
|
|
|
1322 {
|
|
|
1323 bitmap aliases = NULL;
|
|
|
1324 tree sym;
|
|
|
1325 var_ann_t v_ann;
|
|
|
1326
|
|
|
1327 sym = (TREE_CODE (var) == SSA_NAME ? SSA_NAME_VAR (var) : var);
|
|
|
1328 v_ann = var_ann (sym);
|
|
|
1329
|
|
|
1330 /* Mark the statement as having memory operands. */
|
|
|
1331 gimple_set_references_memory (stmt, true);
|
|
|
1332
|
|
|
1333 /* If the variable cannot be modified and this is a VDEF change
|
|
|
1334 it into a VUSE. This happens when read-only variables are marked
|
|
|
1335 call-clobbered and/or aliased to writable variables. So we only
|
|
|
1336 check that this only happens on non-specific stores.
|
|
|
1337
|
|
|
1338 Note that if this is a specific store, i.e. associated with a
|
|
|
1339 MODIFY_EXPR, then we can't suppress the VDEF, lest we run
|
|
|
1340 into validation problems.
|
|
|
1341
|
|
|
1342 This can happen when programs cast away const, leaving us with a
|
|
|
1343 store to read-only memory. If the statement is actually executed
|
|
|
1344 at runtime, then the program is ill formed. If the statement is
|
|
|
1345 not executed then all is well. At the very least, we cannot ICE. */
|
|
|
1346 if ((flags & opf_implicit) && unmodifiable_var_p (var))
|
|
|
1347 flags &= ~opf_def;
|
|
|
1348
|
|
|
1349 /* The variable is not a GIMPLE register. Add it (or its aliases) to
|
|
|
1350 virtual operands, unless the caller has specifically requested
|
|
|
1351 not to add virtual operands (used when adding operands inside an
|
|
|
1352 ADDR_EXPR expression). */
|
|
|
1353 if (flags & opf_no_vops)
|
|
|
1354 return;
|
|
|
1355
|
|
|
1356 if (MTAG_P (var))
|
|
|
1357 aliases = MTAG_ALIASES (var);
|
|
|
1358
|
|
|
1359 if (aliases == NULL)
|
|
|
1360 {
|
|
|
1361 if (!gimple_aliases_computed_p (cfun) && (flags & opf_def))
|
|
|
1362 gimple_set_has_volatile_ops (stmt, true);
|
|
|
1363
|
|
|
1364 /* The variable is not aliased or it is an alias tag. */
|
|
|
1365 if (flags & opf_def)
|
|
|
1366 append_vdef (var);
|
|
|
1367 else
|
|
|
1368 append_vuse (var);
|
|
|
1369 }
|
|
|
1370 else
|
|
|
1371 {
|
|
|
1372 bitmap_iterator bi;
|
|
|
1373 unsigned int i;
|
|
|
1374 bool none_added = true;
|
|
|
1375
|
|
|
1376 /* The variable is aliased. Add its aliases to the virtual
|
|
|
1377 operands. */
|
|
|
1378 gcc_assert (!bitmap_empty_p (aliases));
|
|
|
1379
|
|
|
1380 EXECUTE_IF_SET_IN_BITMAP (aliases, 0, i, bi)
|
|
|
1381 {
|
|
|
1382 tree al = referenced_var (i);
|
|
|
1383
|
|
|
1384 /* Call-clobbered tags may have non-call-clobbered
|
|
|
1385 symbols in their alias sets. Ignore them if we are
|
|
|
1386 adding VOPs for a call site. */
|
|
|
1387 if (is_call_site && !is_call_clobbered (al))
|
|
|
1388 continue;
|
|
|
1389
|
|
|
1390 /* If we do not know the full reference tree or if the access is
|
|
|
1391 unspecified [0, -1], we cannot prune it. Otherwise try doing
|
|
|
1392 so using access_can_touch_variable. */
|
|
|
1393 if (full_ref
|
|
|
1394 && !access_can_touch_variable (full_ref, al, offset, size))
|
|
|
1395 continue;
|
|
|
1396
|
|
|
1397 if (flags & opf_def)
|
|
|
1398 append_vdef (al);
|
|
|
1399 else
|
|
|
1400 append_vuse (al);
|
|
|
1401 none_added = false;
|
|
|
1402 }
|
|
|
1403
|
|
|
1404 if (flags & opf_def)
|
|
|
1405 {
|
|
|
1406 /* If the variable is also an alias tag, add a virtual
|
|
|
1407 operand for it, otherwise we will miss representing
|
|
|
1408 references to the members of the variable's alias set.
|
|
|
1409 This fixes the bug in gcc.c-torture/execute/20020503-1.c.
|
|
|
1410
|
|
|
1411 It is also necessary to add bare defs on clobbers for
|
|
|
1412 SMT's, so that bare SMT uses caused by pruning all the
|
|
|
1413 aliases will link up properly with calls. In order to
|
|
|
1414 keep the number of these bare defs we add down to the
|
|
|
1415 minimum necessary, we keep track of which SMT's were used
|
|
|
1416 alone in statement vdefs or VUSEs. */
|
|
|
1417 if (none_added
|
|
|
1418 || (TREE_CODE (var) == SYMBOL_MEMORY_TAG
|
|
|
1419 && is_call_site))
|
|
|
1420 append_vdef (var);
|
|
|
1421 }
|
|
|
1422 else
|
|
|
1423 {
|
|
|
1424 /* Even if no aliases have been added, we still need to
|
|
|
1425 establish def-use and use-def chains, lest
|
|
|
1426 transformations think that this is not a memory
|
|
|
1427 reference. For an example of this scenario, see
|
|
|
1428 testsuite/g++.dg/opt/cleanup1.C. */
|
|
|
1429 if (none_added)
|
|
|
1430 append_vuse (var);
|
|
|
1431 }
|
|
|
1432 }
|
|
|
1433 }
|
|
|
1434
|
|
|
1435
|
|
|
1436 /* Add *VAR_P to the appropriate operand array for statement STMT.
|
|
|
1437 FLAGS is as in get_expr_operands. If *VAR_P is a GIMPLE register,
|
|
|
1438 it will be added to the statement's real operands, otherwise it is
|
|
|
1439 added to virtual operands. */
|
|
|
1440
|
|
|
1441 static void
|
|
|
1442 add_stmt_operand (tree *var_p, gimple stmt, int flags)
|
|
|
1443 {
|
|
|
1444 tree var, sym;
|
|
|
1445 var_ann_t v_ann;
|
|
|
1446
|
|
|
1447 gcc_assert (SSA_VAR_P (*var_p));
|
|
|
1448
|
|
|
1449 var = *var_p;
|
|
|
1450 sym = (TREE_CODE (var) == SSA_NAME ? SSA_NAME_VAR (var) : var);
|
|
|
1451 v_ann = var_ann (sym);
|
|
|
1452
|
|
|
1453 /* Mark statements with volatile operands. */
|
|
|
1454 if (TREE_THIS_VOLATILE (sym))
|
|
|
1455 gimple_set_has_volatile_ops (stmt, true);
|
|
|
1456
|
|
|
1457 if (is_gimple_reg (sym))
|
|
|
1458 {
|
|
|
1459 /* The variable is a GIMPLE register. Add it to real operands. */
|
|
|
1460 if (flags & opf_def)
|
|
|
1461 append_def (var_p);
|
|
|
1462 else
|
|
|
1463 append_use (var_p);
|
|
|
1464 }
|
|
|
1465 else
|
|
|
1466 add_virtual_operand (var, stmt, flags, NULL_TREE, 0, -1, false);
|
|
|
1467 }
|
|
|
1468
|
|
|
1469 /* Subroutine of get_indirect_ref_operands. ADDR is the address
|
|
|
1470 that is dereferenced, the meaning of the rest of the arguments
|
|
|
1471 is the same as in get_indirect_ref_operands. */
|
|
|
1472
|
|
|
1473 static void
|
|
|
1474 get_addr_dereference_operands (gimple stmt, tree *addr, int flags,
|
|
|
1475 tree full_ref, HOST_WIDE_INT offset,
|
|
|
1476 HOST_WIDE_INT size, bool recurse_on_base)
|
|
|
1477 {
|
|
|
1478 tree ptr = *addr;
|
|
|
1479
|
|
|
1480 /* Mark the statement as having memory operands. */
|
|
|
1481 gimple_set_references_memory (stmt, true);
|
|
|
1482
|
|
|
1483 if (SSA_VAR_P (ptr))
|
|
|
1484 {
|
|
|
1485 struct ptr_info_def *pi = NULL;
|
|
|
1486
|
|
|
1487 /* If PTR has flow-sensitive points-to information, use it. */
|
|
|
1488 if (TREE_CODE (ptr) == SSA_NAME
|
|
|
1489 && (pi = SSA_NAME_PTR_INFO (ptr)) != NULL
|
|
|
1490 && pi->name_mem_tag)
|
|
|
1491 {
|
|
|
1492 /* PTR has its own memory tag. Use it. */
|
|
|
1493 add_virtual_operand (pi->name_mem_tag, stmt, flags,
|
|
|
1494 full_ref, offset, size, false);
|
|
|
1495 }
|
|
|
1496 else
|
|
|
1497 {
|
|
|
1498 /* If PTR is not an SSA_NAME or it doesn't have a name
|
|
|
1499 tag, use its symbol memory tag. */
|
|
|
1500 var_ann_t v_ann;
|
|
|
1501
|
|
|
1502 /* If we are emitting debugging dumps, display a warning if
|
|
|
1503 PTR is an SSA_NAME with no flow-sensitive alias
|
|
|
1504 information. That means that we may need to compute
|
|
|
1505 aliasing again or that a propagation pass forgot to
|
|
|
1506 update the alias information on the pointers. */
|
|
|
1507 if (dump_file
|
|
|
1508 && TREE_CODE (ptr) == SSA_NAME
|
|
|
1509 && (pi == NULL
|
|
|
1510 || (pi->name_mem_tag == NULL_TREE
|
|
|
1511 && !pi->pt_anything))
|
|
|
1512 && gimple_aliases_computed_p (cfun))
|
|
|
1513 {
|
|
|
1514 fprintf (dump_file,
|
|
|
1515 "NOTE: no flow-sensitive alias info for ");
|
|
|
1516 print_generic_expr (dump_file, ptr, dump_flags);
|
|
|
1517 fprintf (dump_file, " in ");
|
|
|
1518 print_gimple_stmt (dump_file, stmt, 0, 0);
|
|
|
1519 }
|
|
|
1520
|
|
|
1521 if (TREE_CODE (ptr) == SSA_NAME)
|
|
|
1522 ptr = SSA_NAME_VAR (ptr);
|
|
|
1523 v_ann = var_ann (ptr);
|
|
|
1524
|
|
|
1525 /* If we don't know what this pointer points to then we have
|
|
|
1526 to make sure to not prune virtual operands based on offset
|
|
|
1527 and size. */
|
|
|
1528 if (v_ann->symbol_mem_tag)
|
|
|
1529 {
|
|
|
1530 add_virtual_operand (v_ann->symbol_mem_tag, stmt, flags,
|
|
|
1531 full_ref, 0, -1, false);
|
|
|
1532 /* Make sure we add the SMT itself. */
|
|
|
1533 if (!(flags & opf_no_vops))
|
|
|
1534 {
|
|
|
1535 if (flags & opf_def)
|
|
|
1536 append_vdef (v_ann->symbol_mem_tag);
|
|
|
1537 else
|
|
|
1538 append_vuse (v_ann->symbol_mem_tag);
|
|
|
1539 }
|
|
|
1540 }
|
|
|
1541
|
|
|
1542 /* Aliasing information is missing; mark statement as
|
|
|
1543 volatile so we won't optimize it out too actively. */
|
|
|
1544 else if (!gimple_aliases_computed_p (cfun)
|
|
|
1545 && (flags & opf_def))
|
|
|
1546 gimple_set_has_volatile_ops (stmt, true);
|
|
|
1547 }
|
|
|
1548 }
|
|
|
1549 else if (TREE_CODE (ptr) == INTEGER_CST)
|
|
|
1550 {
|
|
|
1551 /* If a constant is used as a pointer, we can't generate a real
|
|
|
1552 operand for it but we mark the statement volatile to prevent
|
|
|
1553 optimizations from messing things up. */
|
|
|
1554 gimple_set_has_volatile_ops (stmt, true);
|
|
|
1555 return;
|
|
|
1556 }
|
|
|
1557 else
|
|
|
1558 {
|
|
|
1559 /* Ok, this isn't even is_gimple_min_invariant. Something's broke. */
|
|
|
1560 gcc_unreachable ();
|
|
|
1561 }
|
|
|
1562
|
|
|
1563 /* If requested, add a USE operand for the base pointer. */
|
|
|
1564 if (recurse_on_base)
|
|
|
1565 get_expr_operands (stmt, addr, opf_use);
|
|
|
1566 }
|
|
|
1567
|
|
|
1568
|
|
|
1569 /* A subroutine of get_expr_operands to handle INDIRECT_REF,
|
|
|
1570 ALIGN_INDIRECT_REF and MISALIGNED_INDIRECT_REF.
|
|
|
1571
|
|
|
1572 STMT is the statement being processed, EXPR is the INDIRECT_REF
|
|
|
1573 that got us here.
|
|
|
1574
|
|
|
1575 FLAGS is as in get_expr_operands.
|
|
|
1576
|
|
|
1577 FULL_REF contains the full pointer dereference expression, if we
|
|
|
1578 have it, or NULL otherwise.
|
|
|
1579
|
|
|
1580 OFFSET and SIZE are the location of the access inside the
|
|
|
1581 dereferenced pointer, if known.
|
|
|
1582
|
|
|
1583 RECURSE_ON_BASE should be set to true if we want to continue
|
|
|
1584 calling get_expr_operands on the base pointer, and false if
|
|
|
1585 something else will do it for us. */
|
|
|
1586
|
|
|
1587 static void
|
|
|
1588 get_indirect_ref_operands (gimple stmt, tree expr, int flags, tree full_ref,
|
|
|
1589 HOST_WIDE_INT offset, HOST_WIDE_INT size,
|
|
|
1590 bool recurse_on_base)
|
|
|
1591 {
|
|
|
1592 tree *pptr = &TREE_OPERAND (expr, 0);
|
|
|
1593
|
|
|
1594 if (TREE_THIS_VOLATILE (expr))
|
|
|
1595 gimple_set_has_volatile_ops (stmt, true);
|
|
|
1596
|
|
|
1597 get_addr_dereference_operands (stmt, pptr, flags, full_ref, offset, size,
|
|
|
1598 recurse_on_base);
|
|
|
1599 }
|
|
|
1600
|
|
|
1601
|
|
|
1602 /* A subroutine of get_expr_operands to handle TARGET_MEM_REF. */
|
|
|
1603
|
|
|
1604 static void
|
|
|
1605 get_tmr_operands (gimple stmt, tree expr, int flags)
|
|
|
1606 {
|
|
|
1607 tree tag;
|
|
|
1608
|
|
|
1609 /* Mark the statement as having memory operands. */
|
|
|
1610 gimple_set_references_memory (stmt, true);
|
|
|
1611
|
|
|
1612 /* First record the real operands. */
|
|
|
1613 get_expr_operands (stmt, &TMR_BASE (expr), opf_use);
|
|
|
1614 get_expr_operands (stmt, &TMR_INDEX (expr), opf_use);
|
|
|
1615
|
|
|
1616 if (TMR_SYMBOL (expr))
|
|
|
1617 gimple_add_to_addresses_taken (stmt, TMR_SYMBOL (expr));
|
|
|
1618
|
|
|
1619 tag = TMR_TAG (expr);
|
|
|
1620 if (!tag)
|
|
|
1621 {
|
|
|
1622 /* Something weird, so ensure that we will be careful. */
|
|
|
1623 gimple_set_has_volatile_ops (stmt, true);
|
|
|
1624 return;
|
|
|
1625 }
|
|
|
1626 if (!MTAG_P (tag))
|
|
|
1627 {
|
|
|
1628 get_expr_operands (stmt, &tag, flags);
|
|
|
1629 return;
|
|
|
1630 }
|
|
|
1631
|
|
|
1632 add_virtual_operand (tag, stmt, flags, expr, 0, -1, false);
|
|
|
1633 }
|
|
|
1634
|
|
|
1635
|
|
|
1636 /* Add clobbering definitions for .GLOBAL_VAR or for each of the call
|
|
|
1637 clobbered variables in the function. */
|
|
|
1638
|
|
|
1639 static void
|
|
|
1640 add_call_clobber_ops (gimple stmt, tree callee ATTRIBUTE_UNUSED)
|
|
|
1641 {
|
|
|
1642 unsigned u;
|
|
|
1643 bitmap_iterator bi;
|
|
|
1644 bitmap not_read_b, not_written_b;
|
|
|
1645
|
|
|
1646 gcc_assert (!(gimple_call_flags (stmt) & (ECF_PURE | ECF_CONST)));
|
|
|
1647
|
|
|
1648 /* If we created .GLOBAL_VAR earlier, just use it. */
|
|
|
1649 if (gimple_global_var (cfun))
|
|
|
1650 {
|
|
|
1651 tree var = gimple_global_var (cfun);
|
|
|
1652 add_virtual_operand (var, stmt, opf_def, NULL, 0, -1, true);
|
|
|
1653 return;
|
|
|
1654 }
|
|
|
1655
|
|
|
1656 /* Get info for local and module level statics. There is a bit
|
|
|
1657 set for each static if the call being processed does not read
|
|
|
1658 or write that variable. */
|
|
|
1659 not_read_b = callee ? ipa_reference_get_not_read_global (cgraph_node (callee)) : NULL;
|
|
|
1660 not_written_b = callee ? ipa_reference_get_not_written_global (cgraph_node (callee)) : NULL;
|
|
|
1661
|
|
|
1662 /* Add a VDEF operand for every call clobbered variable. */
|
|
|
1663 EXECUTE_IF_SET_IN_BITMAP (gimple_call_clobbered_vars (cfun), 0, u, bi)
|
|
|
1664 {
|
|
|
1665 tree var = referenced_var_lookup (u);
|
|
|
1666 tree real_var = var;
|
|
|
1667 bool not_read;
|
|
|
1668 bool not_written;
|
|
|
1669
|
|
|
1670 not_read = not_read_b
|
|
|
1671 ? bitmap_bit_p (not_read_b, DECL_UID (real_var))
|
|
|
1672 : false;
|
|
|
1673
|
|
|
1674 not_written = not_written_b
|
|
|
1675 ? bitmap_bit_p (not_written_b, DECL_UID (real_var))
|
|
|
1676 : false;
|
|
|
1677 gcc_assert (!unmodifiable_var_p (var));
|
|
|
1678
|
|
|
1679 clobber_stats.clobbered_vars++;
|
|
|
1680
|
|
|
1681 /* See if this variable is really clobbered by this function. */
|
|
|
1682
|
|
|
1683 if (not_written)
|
|
|
1684 {
|
|
|
1685 clobber_stats.static_write_clobbers_avoided++;
|
|
|
1686 if (!not_read)
|
|
|
1687 add_virtual_operand (var, stmt, opf_use, NULL, 0, -1, true);
|
|
|
1688 else
|
|
|
1689 clobber_stats.static_read_clobbers_avoided++;
|
|
|
1690 }
|
|
|
1691 else
|
|
|
1692 add_virtual_operand (var, stmt, opf_def, NULL, 0, -1, true);
|
|
|
1693 }
|
|
|
1694 }
|
|
|
1695
|
|
|
1696
|
|
|
1697 /* Add VUSE operands for .GLOBAL_VAR or all call clobbered variables in the
|
|
|
1698 function. */
|
|
|
1699
|
|
|
1700 static void
|
|
|
1701 add_call_read_ops (gimple stmt, tree callee ATTRIBUTE_UNUSED)
|
|
|
1702 {
|
|
|
1703 unsigned u;
|
|
|
1704 bitmap_iterator bi;
|
|
|
1705 bitmap not_read_b;
|
|
|
1706
|
|
|
1707 /* Const functions do not reference memory. */
|
|
|
1708 if (gimple_call_flags (stmt) & ECF_CONST)
|
|
|
1709 return;
|
|
|
1710
|
|
|
1711 not_read_b = callee ? ipa_reference_get_not_read_global (cgraph_node (callee)) : NULL;
|
|
|
1712
|
|
|
1713 /* For pure functions we compute non-escaped uses separately. */
|
|
|
1714 if (gimple_call_flags (stmt) & ECF_PURE)
|
|
|
1715 EXECUTE_IF_SET_IN_BITMAP (gimple_call_used_vars (cfun), 0, u, bi)
|
|
|
1716 {
|
|
|
1717 tree var = referenced_var_lookup (u);
|
|
|
1718 tree real_var = var;
|
|
|
1719 bool not_read;
|
|
|
1720
|
|
|
1721 if (unmodifiable_var_p (var))
|
|
|
1722 continue;
|
|
|
1723
|
|
|
1724 not_read = not_read_b
|
|
|
1725 ? bitmap_bit_p (not_read_b, DECL_UID (real_var))
|
|
|
1726 : false;
|
|
|
1727
|
|
|
1728 clobber_stats.readonly_clobbers++;
|
|
|
1729
|
|
|
1730 /* See if this variable is really used by this function. */
|
|
|
1731 if (!not_read)
|
|
|
1732 add_virtual_operand (var, stmt, opf_use, NULL, 0, -1, true);
|
|
|
1733 else
|
|
|
1734 clobber_stats.static_readonly_clobbers_avoided++;
|
|
|
1735 }
|
|
|
1736
|
|
|
1737 /* Add a VUSE for .GLOBAL_VAR if it has been created. See
|
|
|
1738 add_referenced_var for the heuristic used to decide whether to
|
|
|
1739 create .GLOBAL_VAR. */
|
|
|
1740 if (gimple_global_var (cfun))
|
|
|
1741 {
|
|
|
1742 tree var = gimple_global_var (cfun);
|
|
|
1743 add_virtual_operand (var, stmt, opf_use, NULL, 0, -1, true);
|
|
|
1744 return;
|
|
|
1745 }
|
|
|
1746
|
|
|
1747 /* Add a VUSE for each call-clobbered variable. */
|
|
|
1748 EXECUTE_IF_SET_IN_BITMAP (gimple_call_clobbered_vars (cfun), 0, u, bi)
|
|
|
1749 {
|
|
|
1750 tree var = referenced_var (u);
|
|
|
1751 tree real_var = var;
|
|
|
1752 bool not_read;
|
|
|
1753
|
|
|
1754 clobber_stats.readonly_clobbers++;
|
|
|
1755
|
|
|
1756 not_read = not_read_b ? bitmap_bit_p (not_read_b, DECL_UID (real_var))
|
|
|
1757 : false;
|
|
|
1758
|
|
|
1759 if (not_read)
|
|
|
1760 {
|
|
|
1761 clobber_stats.static_readonly_clobbers_avoided++;
|
|
|
1762 continue;
|
|
|
1763 }
|
|
|
1764
|
|
|
1765 add_virtual_operand (var, stmt, opf_use, NULL, 0, -1, true);
|
|
|
1766 }
|
|
|
1767 }
|
|
|
1768
|
|
|
1769
|
|
|
1770 /* If STMT is a call that may clobber globals and other symbols that
|
|
|
1771 escape, add them to the VDEF/VUSE lists for it. */
|
|
|
1772
|
|
|
1773 static void
|
|
|
1774 maybe_add_call_clobbered_vops (gimple stmt)
|
|
|
1775 {
|
|
|
1776 int call_flags = gimple_call_flags (stmt);
|
|
|
1777
|
|
|
1778 /* Mark the statement as having memory operands. */
|
|
|
1779 gimple_set_references_memory (stmt, true);
|
|
|
1780
|
|
|
1781 /* If aliases have been computed already, add VDEF or VUSE
|
|
|
1782 operands for all the symbols that have been found to be
|
|
|
1783 call-clobbered. */
|
|
|
1784 if (gimple_aliases_computed_p (cfun) && !(call_flags & ECF_NOVOPS))
|
|
|
1785 {
|
|
|
1786 /* A 'pure' or a 'const' function never call-clobbers anything.
|
|
|
1787 A 'noreturn' function might, but since we don't return anyway
|
|
|
1788 there is no point in recording that. */
|
|
|
1789 if (!(call_flags & (ECF_PURE | ECF_CONST | ECF_NORETURN)))
|
|
|
1790 add_call_clobber_ops (stmt, gimple_call_fndecl (stmt));
|
|
|
1791 else if (!(call_flags & ECF_CONST))
|
|
|
1792 add_call_read_ops (stmt, gimple_call_fndecl (stmt));
|
|
|
1793 }
|
|
|
1794 }
|
|
|
1795
|
|
|
1796
|
|
|
1797 /* Scan operands in the ASM_EXPR stmt referred to in INFO. */
|
|
|
1798
|
|
|
1799 static void
|
|
|
1800 get_asm_expr_operands (gimple stmt)
|
|
|
1801 {
|
|
|
1802 size_t i, noutputs;
|
|
|
1803 const char **oconstraints;
|
|
|
1804 const char *constraint;
|
|
|
1805 bool allows_mem, allows_reg, is_inout;
|
|
|
1806
|
|
|
1807 noutputs = gimple_asm_noutputs (stmt);
|
|
|
1808 oconstraints = (const char **) alloca ((noutputs) * sizeof (const char *));
|
|
|
1809
|
|
|
1810 /* Gather all output operands. */
|
|
|
1811 for (i = 0; i < gimple_asm_noutputs (stmt); i++)
|
|
|
1812 {
|
|
|
1813 tree link = gimple_asm_output_op (stmt, i);
|
|
|
1814 constraint = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (link)));
|
|
|
1815 oconstraints[i] = constraint;
|
|
|
1816 parse_output_constraint (&constraint, i, 0, 0, &allows_mem,
|
|
|
1817 &allows_reg, &is_inout);
|
|
|
1818
|
|
|
1819 /* This should have been split in gimplify_asm_expr. */
|
|
|
1820 gcc_assert (!allows_reg || !is_inout);
|
|
|
1821
|
|
|
1822 /* Memory operands are addressable. Note that STMT needs the
|
|
|
1823 address of this operand. */
|
|
|
1824 if (!allows_reg && allows_mem)
|
|
|
1825 {
|
|
|
1826 tree t = get_base_address (TREE_VALUE (link));
|
|
|
1827 if (t && DECL_P (t))
|
|
|
1828 gimple_add_to_addresses_taken (stmt, t);
|
|
|
1829 }
|
|
|
1830
|
|
|
1831 get_expr_operands (stmt, &TREE_VALUE (link), opf_def);
|
|
|
1832 }
|
|
|
1833
|
|
|
1834 /* Gather all input operands. */
|
|
|
1835 for (i = 0; i < gimple_asm_ninputs (stmt); i++)
|
|
|
1836 {
|
|
|
1837 tree link = gimple_asm_input_op (stmt, i);
|
|
|
1838 constraint = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (link)));
|
|
|
1839 parse_input_constraint (&constraint, 0, 0, noutputs, 0, oconstraints,
|
|
|
1840 &allows_mem, &allows_reg);
|
|
|
1841
|
|
|
1842 /* Memory operands are addressable. Note that STMT needs the
|
|
|
1843 address of this operand. */
|
|
|
1844 if (!allows_reg && allows_mem)
|
|
|
1845 {
|
|
|
1846 tree t = get_base_address (TREE_VALUE (link));
|
|
|
1847 if (t && DECL_P (t))
|
|
|
1848 gimple_add_to_addresses_taken (stmt, t);
|
|
|
1849 }
|
|
|
1850
|
|
|
1851 get_expr_operands (stmt, &TREE_VALUE (link), 0);
|
|
|
1852 }
|
|
|
1853
|
|
|
1854 /* Clobber all memory and addressable symbols for asm ("" : : : "memory"); */
|
|
|
1855 for (i = 0; i < gimple_asm_nclobbers (stmt); i++)
|
|
|
1856 {
|
|
|
1857 tree link = gimple_asm_clobber_op (stmt, i);
|
|
|
1858 if (strcmp (TREE_STRING_POINTER (TREE_VALUE (link)), "memory") == 0)
|
|
|
1859 {
|
|
|
1860 unsigned i;
|
|
|
1861 bitmap_iterator bi;
|
|
|
1862
|
|
|
1863 /* Mark the statement as having memory operands. */
|
|
|
1864 gimple_set_references_memory (stmt, true);
|
|
|
1865
|
|
|
1866 EXECUTE_IF_SET_IN_BITMAP (gimple_call_clobbered_vars (cfun), 0, i, bi)
|
|
|
1867 {
|
|
|
1868 tree var = referenced_var (i);
|
|
|
1869 add_stmt_operand (&var, stmt, opf_def | opf_implicit);
|
|
|
1870 }
|
|
|
1871
|
|
|
1872 EXECUTE_IF_SET_IN_BITMAP (gimple_addressable_vars (cfun), 0, i, bi)
|
|
|
1873 {
|
|
|
1874 tree var = referenced_var (i);
|
|
|
1875 add_stmt_operand (&var, stmt, opf_def | opf_implicit);
|
|
|
1876 }
|
|
|
1877 break;
|
|
|
1878 }
|
|
|
1879 }
|
|
|
1880 }
|
|
|
1881
|
|
|
1882
|
|
|
1883 /* Recursively scan the expression pointed to by EXPR_P in statement
|
|
|
1884 STMT. FLAGS is one of the OPF_* constants modifying how to
|
|
|
1885 interpret the operands found. */
|
|
|
1886
|
|
|
1887 static void
|
|
|
1888 get_expr_operands (gimple stmt, tree *expr_p, int flags)
|
|
|
1889 {
|
|
|
1890 enum tree_code code;
|
|
|
1891 enum tree_code_class codeclass;
|
|
|
1892 tree expr = *expr_p;
|
|
|
1893
|
|
|
1894 if (expr == NULL)
|
|
|
1895 return;
|
|
|
1896
|
|
|
1897 code = TREE_CODE (expr);
|
|
|
1898 codeclass = TREE_CODE_CLASS (code);
|
|
|
1899
|
|
|
1900 switch (code)
|
|
|
1901 {
|
|
|
1902 case ADDR_EXPR:
|
|
|
1903 /* Taking the address of a variable does not represent a
|
|
|
1904 reference to it, but the fact that the statement takes its
|
|
|
1905 address will be of interest to some passes (e.g. alias
|
|
|
1906 resolution). */
|
|
|
1907 gimple_add_to_addresses_taken (stmt, TREE_OPERAND (expr, 0));
|
|
|
1908
|
|
|
1909 /* If the address is invariant, there may be no interesting
|
|
|
1910 variable references inside. */
|
|
|
1911 if (is_gimple_min_invariant (expr))
|
|
|
1912 return;
|
|
|
1913
|
|
|
1914 /* Otherwise, there may be variables referenced inside but there
|
|
|
1915 should be no VUSEs created, since the referenced objects are
|
|
|
1916 not really accessed. The only operands that we should find
|
|
|
1917 here are ARRAY_REF indices which will always be real operands
|
|
|
1918 (GIMPLE does not allow non-registers as array indices). */
|
|
|
1919 flags |= opf_no_vops;
|
|
|
1920 get_expr_operands (stmt, &TREE_OPERAND (expr, 0), flags);
|
|
|
1921 return;
|
|
|
1922
|
|
|
1923 case SSA_NAME:
|
|
|
1924 case SYMBOL_MEMORY_TAG:
|
|
|
1925 case NAME_MEMORY_TAG:
|
|
|
1926 add_stmt_operand (expr_p, stmt, flags);
|
|
|
1927 return;
|
|
|
1928
|
|
|
1929 case VAR_DECL:
|
|
|
1930 case PARM_DECL:
|
|
|
1931 case RESULT_DECL:
|
|
|
1932 add_stmt_operand (expr_p, stmt, flags);
|
|
|
1933 return;
|
|
|
1934
|
|
|
1935 case MISALIGNED_INDIRECT_REF:
|
|
|
1936 get_expr_operands (stmt, &TREE_OPERAND (expr, 1), flags);
|
|
|
1937 /* fall through */
|
|
|
1938
|
|
|
1939 case ALIGN_INDIRECT_REF:
|
|
|
1940 case INDIRECT_REF:
|
|
|
1941 get_indirect_ref_operands (stmt, expr, flags, expr, 0, -1, true);
|
|
|
1942 return;
|
|
|
1943
|
|
|
1944 case TARGET_MEM_REF:
|
|
|
1945 get_tmr_operands (stmt, expr, flags);
|
|
|
1946 return;
|
|
|
1947
|
|
|
1948 case ARRAY_REF:
|
|
|
1949 case ARRAY_RANGE_REF:
|
|
|
1950 case COMPONENT_REF:
|
|
|
1951 case REALPART_EXPR:
|
|
|
1952 case IMAGPART_EXPR:
|
|
|
1953 {
|
|
|
1954 tree ref;
|
|
|
1955 HOST_WIDE_INT offset, size, maxsize;
|
|
|
1956
|
|
|
1957 if (TREE_THIS_VOLATILE (expr))
|
|
|
1958 gimple_set_has_volatile_ops (stmt, true);
|
|
|
1959
|
|
|
1960 ref = get_ref_base_and_extent (expr, &offset, &size, &maxsize);
|
|
|
1961 if (TREE_CODE (ref) == INDIRECT_REF)
|
|
|
1962 {
|
|
|
1963 get_indirect_ref_operands (stmt, ref, flags, expr, offset,
|
|
|
1964 maxsize, false);
|
|
|
1965 flags |= opf_no_vops;
|
|
|
1966 }
|
|
|
1967
|
|
|
1968 get_expr_operands (stmt, &TREE_OPERAND (expr, 0), flags);
|
|
|
1969
|
|
|
1970 if (code == COMPONENT_REF)
|
|
|
1971 {
|
|
|
1972 if (TREE_THIS_VOLATILE (TREE_OPERAND (expr, 1)))
|
|
|
1973 gimple_set_has_volatile_ops (stmt, true);
|
|
|
1974 get_expr_operands (stmt, &TREE_OPERAND (expr, 2), opf_use);
|
|
|
1975 }
|
|
|
1976 else if (code == ARRAY_REF || code == ARRAY_RANGE_REF)
|
|
|
1977 {
|
|
|
1978 get_expr_operands (stmt, &TREE_OPERAND (expr, 1), opf_use);
|
|
|
1979 get_expr_operands (stmt, &TREE_OPERAND (expr, 2), opf_use);
|
|
|
1980 get_expr_operands (stmt, &TREE_OPERAND (expr, 3), opf_use);
|
|
|
1981 }
|
|
|
1982
|
|
|
1983 return;
|
|
|
1984 }
|
|
|
1985
|
|
|
1986 case WITH_SIZE_EXPR:
|
|
|
1987 /* WITH_SIZE_EXPR is a pass-through reference to its first argument,
|
|
|
1988 and an rvalue reference to its second argument. */
|
|
|
1989 get_expr_operands (stmt, &TREE_OPERAND (expr, 1), opf_use);
|
|
|
1990 get_expr_operands (stmt, &TREE_OPERAND (expr, 0), flags);
|
|
|
1991 return;
|
|
|
1992
|
|
|
1993 case COND_EXPR:
|
|
|
1994 case VEC_COND_EXPR:
|
|
|
1995 get_expr_operands (stmt, &TREE_OPERAND (expr, 0), opf_use);
|
|
|
1996 get_expr_operands (stmt, &TREE_OPERAND (expr, 1), opf_use);
|
|
|
1997 get_expr_operands (stmt, &TREE_OPERAND (expr, 2), opf_use);
|
|
|
1998 return;
|
|
|
1999
|
|
|
2000 case CONSTRUCTOR:
|
|
|
2001 {
|
|
|
2002 /* General aggregate CONSTRUCTORs have been decomposed, but they
|
|
|
2003 are still in use as the COMPLEX_EXPR equivalent for vectors. */
|
|
|
2004 constructor_elt *ce;
|
|
|
2005 unsigned HOST_WIDE_INT idx;
|
|
|
2006
|
|
|
2007 for (idx = 0;
|
|
|
2008 VEC_iterate (constructor_elt, CONSTRUCTOR_ELTS (expr), idx, ce);
|
|
|
2009 idx++)
|
|
|
2010 get_expr_operands (stmt, &ce->value, opf_use);
|
|
|
2011
|
|
|
2012 return;
|
|
|
2013 }
|
|
|
2014
|
|
|
2015 case BIT_FIELD_REF:
|
|
|
2016 if (TREE_THIS_VOLATILE (expr))
|
|
|
2017 gimple_set_has_volatile_ops (stmt, true);
|
|
|
2018 /* FALLTHRU */
|
|
|
2019
|
|
|
2020 case TRUTH_NOT_EXPR:
|
|
|
2021 case VIEW_CONVERT_EXPR:
|
|
|
2022 do_unary:
|
|
|
2023 get_expr_operands (stmt, &TREE_OPERAND (expr, 0), flags);
|
|
|
2024 return;
|
|
|
2025
|
|
|
2026 case TRUTH_AND_EXPR:
|
|
|
2027 case TRUTH_OR_EXPR:
|
|
|
2028 case TRUTH_XOR_EXPR:
|
|
|
2029 case COMPOUND_EXPR:
|
|
|
2030 case OBJ_TYPE_REF:
|
|
|
2031 case ASSERT_EXPR:
|
|
|
2032 do_binary:
|
|
|
2033 {
|
|
|
2034 get_expr_operands (stmt, &TREE_OPERAND (expr, 0), flags);
|
|
|
2035 get_expr_operands (stmt, &TREE_OPERAND (expr, 1), flags);
|
|
|
2036 return;
|
|
|
2037 }
|
|
|
2038
|
|
|
2039 case DOT_PROD_EXPR:
|
|
|
2040 case REALIGN_LOAD_EXPR:
|
|
|
2041 {
|
|
|
2042 get_expr_operands (stmt, &TREE_OPERAND (expr, 0), flags);
|
|
|
2043 get_expr_operands (stmt, &TREE_OPERAND (expr, 1), flags);
|
|
|
2044 get_expr_operands (stmt, &TREE_OPERAND (expr, 2), flags);
|
|
|
2045 return;
|
|
|
2046 }
|
|
|
2047
|
|
|
2048 case CHANGE_DYNAMIC_TYPE_EXPR:
|
|
|
2049 gcc_unreachable ();
|
|
|
2050
|
|
|
2051 case FUNCTION_DECL:
|
|
|
2052 case LABEL_DECL:
|
|
|
2053 case CONST_DECL:
|
|
|
2054 case CASE_LABEL_EXPR:
|
|
|
2055 case FILTER_EXPR:
|
|
|
2056 case EXC_PTR_EXPR:
|
|
|
2057 /* Expressions that make no memory references. */
|
|
|
2058 return;
|
|
|
2059
|
|
|
2060 default:
|
|
|
2061 if (codeclass == tcc_unary)
|
|
|
2062 goto do_unary;
|
|
|
2063 if (codeclass == tcc_binary || codeclass == tcc_comparison)
|
|
|
2064 goto do_binary;
|
|
|
2065 if (codeclass == tcc_constant || codeclass == tcc_type)
|
|
|
2066 return;
|
|
|
2067 }
|
|
|
2068
|
|
|
2069 /* If we get here, something has gone wrong. */
|
|
|
2070 #ifdef ENABLE_CHECKING
|
|
|
2071 fprintf (stderr, "unhandled expression in get_expr_operands():\n");
|
|
|
2072 debug_tree (expr);
|
|
|
2073 fputs ("\n", stderr);
|
|
|
2074 #endif
|
|
|
2075 gcc_unreachable ();
|
|
|
2076 }
|
|
|
2077
|
|
|
2078
|
|
|
2079 /* Parse STMT looking for operands. When finished, the various
|
|
|
2080 build_* operand vectors will have potential operands in them. */
|
|
|
2081
|
|
|
2082 static void
|
|
|
2083 parse_ssa_operands (gimple stmt)
|
|
|
2084 {
|
|
|
2085 enum gimple_code code = gimple_code (stmt);
|
|
|
2086
|
|
|
2087 if (code == GIMPLE_ASM)
|
|
|
2088 get_asm_expr_operands (stmt);
|
|
|
2089 else
|
|
|
2090 {
|
|
|
2091 size_t i, start = 0;
|
|
|
2092
|
|
|
2093 if (code == GIMPLE_ASSIGN || code == GIMPLE_CALL)
|
|
|
2094 {
|
|
|
2095 get_expr_operands (stmt, gimple_op_ptr (stmt, 0), opf_def);
|
|
|
2096 start = 1;
|
|
|
2097 }
|
|
|
2098
|
|
|
2099 for (i = start; i < gimple_num_ops (stmt); i++)
|
|
|
2100 get_expr_operands (stmt, gimple_op_ptr (stmt, i), opf_use);
|
|
|
2101
|
|
|
2102 /* Add call-clobbered operands, if needed. */
|
|
|
2103 if (code == GIMPLE_CALL)
|
|
|
2104 maybe_add_call_clobbered_vops (stmt);
|
|
|
2105 }
|
|
|
2106 }
|
|
|
2107
|
|
|
2108
|
|
|
2109 /* Create an operands cache for STMT. */
|
|
|
2110
|
|
|
2111 static void
|
|
|
2112 build_ssa_operands (gimple stmt)
|
|
|
2113 {
|
|
|
2114 /* Initially assume that the statement has no volatile operands and
|
|
|
2115 makes no memory references. */
|
|
|
2116 gimple_set_has_volatile_ops (stmt, false);
|
|
|
2117 gimple_set_references_memory (stmt, false);
|
|
|
2118
|
|
|
2119 /* Just clear the bitmap so we don't end up reallocating it over and over. */
|
|
|
2120 if (gimple_addresses_taken (stmt))
|
|
|
2121 bitmap_clear (gimple_addresses_taken (stmt));
|
|
|
2122
|
|
|
2123 start_ssa_stmt_operands ();
|
|
|
2124 parse_ssa_operands (stmt);
|
|
|
2125 operand_build_sort_virtual (build_vuses);
|
|
|
2126 operand_build_sort_virtual (build_vdefs);
|
|
|
2127 finalize_ssa_stmt_operands (stmt);
|
|
|
2128
|
|
|
2129 /* For added safety, assume that statements with volatile operands
|
|
|
2130 also reference memory. */
|
|
|
2131 if (gimple_has_volatile_ops (stmt))
|
|
|
2132 gimple_set_references_memory (stmt, true);
|
|
|
2133 }
|
|
|
2134
|
|
|
2135
|
|
|
2136 /* Releases the operands of STMT back to their freelists, and clears
|
|
|
2137 the stmt operand lists. */
|
|
|
2138
|
|
|
2139 void
|
|
|
2140 free_stmt_operands (gimple stmt)
|
|
|
2141 {
|
|
|
2142 def_optype_p defs = gimple_def_ops (stmt), last_def;
|
|
|
2143 use_optype_p uses = gimple_use_ops (stmt), last_use;
|
|
|
2144 voptype_p vuses = gimple_vuse_ops (stmt);
|
|
|
2145 voptype_p vdefs = gimple_vdef_ops (stmt), vdef, next_vdef;
|
|
|
2146 unsigned i;
|
|
|
2147
|
|
|
2148 if (defs)
|
|
|
2149 {
|
|
|
2150 for (last_def = defs; last_def->next; last_def = last_def->next)
|
|
|
2151 continue;
|
|
|
2152 last_def->next = gimple_ssa_operands (cfun)->free_defs;
|
|
|
2153 gimple_ssa_operands (cfun)->free_defs = defs;
|
|
|
2154 gimple_set_def_ops (stmt, NULL);
|
|
|
2155 }
|
|
|
2156
|
|
|
2157 if (uses)
|
|
|
2158 {
|
|
|
2159 for (last_use = uses; last_use->next; last_use = last_use->next)
|
|
|
2160 delink_imm_use (USE_OP_PTR (last_use));
|
|
|
2161 delink_imm_use (USE_OP_PTR (last_use));
|
|
|
2162 last_use->next = gimple_ssa_operands (cfun)->free_uses;
|
|
|
2163 gimple_ssa_operands (cfun)->free_uses = uses;
|
|
|
2164 gimple_set_use_ops (stmt, NULL);
|
|
|
2165 }
|
|
|
2166
|
|
|
2167 if (vuses)
|
|
|
2168 {
|
|
|
2169 for (i = 0; i < VUSE_NUM (vuses); i++)
|
|
|
2170 delink_imm_use (VUSE_OP_PTR (vuses, i));
|
|
|
2171 add_vop_to_freelist (vuses);
|
|
|
2172 gimple_set_vuse_ops (stmt, NULL);
|
|
|
2173 }
|
|
|
2174
|
|
|
2175 if (vdefs)
|
|
|
2176 {
|
|
|
2177 for (vdef = vdefs; vdef; vdef = next_vdef)
|
|
|
2178 {
|
|
|
2179 next_vdef = vdef->next;
|
|
|
2180 delink_imm_use (VDEF_OP_PTR (vdef, 0));
|
|
|
2181 add_vop_to_freelist (vdef);
|
|
|
2182 }
|
|
|
2183 gimple_set_vdef_ops (stmt, NULL);
|
|
|
2184 }
|
|
|
2185
|
|
|
2186 if (gimple_has_ops (stmt))
|
|
|
2187 gimple_set_addresses_taken (stmt, NULL);
|
|
|
2188
|
|
|
2189 if (gimple_has_mem_ops (stmt))
|
|
|
2190 {
|
|
|
2191 gimple_set_stored_syms (stmt, NULL, &operands_bitmap_obstack);
|
|
|
2192 gimple_set_loaded_syms (stmt, NULL, &operands_bitmap_obstack);
|
|
|
2193 }
|
|
|
2194 }
|
|
|
2195
|
|
|
2196
|
|
|
2197 /* Get the operands of statement STMT. */
|
|
|
2198
|
|
|
2199 void
|
|
|
2200 update_stmt_operands (gimple stmt)
|
|
|
2201 {
|
|
|
2202 /* If update_stmt_operands is called before SSA is initialized, do
|
|
|
2203 nothing. */
|
|
|
2204 if (!ssa_operands_active ())
|
|
|
2205 return;
|
|
|
2206
|
|
|
2207 timevar_push (TV_TREE_OPS);
|
|
|
2208
|
|
|
2209 gcc_assert (gimple_modified_p (stmt));
|
|
|
2210 build_ssa_operands (stmt);
|
|
|
2211 gimple_set_modified (stmt, false);
|
|
|
2212
|
|
|
2213 timevar_pop (TV_TREE_OPS);
|
|
|
2214 }
|
|
|
2215
|
|
|
2216
|
|
|
2217 /* Copies virtual operands from SRC to DST. */
|
|
|
2218
|
|
|
2219 void
|
|
|
2220 copy_virtual_operands (gimple dest, gimple src)
|
|
|
2221 {
|
|
|
2222 unsigned int i, n;
|
|
|
2223 voptype_p src_vuses, dest_vuses;
|
|
|
2224 voptype_p src_vdefs, dest_vdefs;
|
|
|
2225 struct voptype_d vuse;
|
|
|
2226 struct voptype_d vdef;
|
|
|
2227
|
|
|
2228 if (!gimple_has_mem_ops (src))
|
|
|
2229 return;
|
|
|
2230
|
|
|
2231 gimple_set_vdef_ops (dest, NULL);
|
|
|
2232 gimple_set_vuse_ops (dest, NULL);
|
|
|
2233
|
|
|
2234 gimple_set_stored_syms (dest, gimple_stored_syms (src),
|
|
|
2235 &operands_bitmap_obstack);
|
|
|
2236 gimple_set_loaded_syms (dest, gimple_loaded_syms (src),
|
|
|
2237 &operands_bitmap_obstack);
|
|
|
2238
|
|
|
2239 /* Copy all the VUSE operators and corresponding operands. */
|
|
|
2240 dest_vuses = &vuse;
|
|
|
2241 for (src_vuses = gimple_vuse_ops (src);
|
|
|
2242 src_vuses;
|
|
|
2243 src_vuses = src_vuses->next)
|
|
|
2244 {
|
|
|
2245 n = VUSE_NUM (src_vuses);
|
|
|
2246 dest_vuses = add_vuse_op (dest, NULL_TREE, n, dest_vuses);
|
|
|
2247 for (i = 0; i < n; i++)
|
|
|
2248 SET_USE (VUSE_OP_PTR (dest_vuses, i), VUSE_OP (src_vuses, i));
|
|
|
2249
|
|
|
2250 if (gimple_vuse_ops (dest) == NULL)
|
|
|
2251 gimple_set_vuse_ops (dest, vuse.next);
|
|
|
2252 }
|
|
|
2253
|
|
|
2254 /* Copy all the VDEF operators and corresponding operands. */
|
|
|
2255 dest_vdefs = &vdef;
|
|
|
2256 for (src_vdefs = gimple_vdef_ops (src);
|
|
|
2257 src_vdefs;
|
|
|
2258 src_vdefs = src_vdefs->next)
|
|
|
2259 {
|
|
|
2260 n = VUSE_NUM (src_vdefs);
|
|
|
2261 dest_vdefs = add_vdef_op (dest, NULL_TREE, n, dest_vdefs);
|
|
|
2262 VDEF_RESULT (dest_vdefs) = VDEF_RESULT (src_vdefs);
|
|
|
2263 for (i = 0; i < n; i++)
|
|
|
2264 SET_USE (VUSE_OP_PTR (dest_vdefs, i), VUSE_OP (src_vdefs, i));
|
|
|
2265
|
|
|
2266 if (gimple_vdef_ops (dest) == NULL)
|
|
|
2267 gimple_set_vdef_ops (dest, vdef.next);
|
|
|
2268 }
|
|
|
2269 }
|
|
|
2270
|
|
|
2271
|
|
|
2272 /* Specifically for use in DOM's expression analysis. Given a store, we
|
|
|
2273 create an artificial stmt which looks like a load from the store, this can
|
|
|
2274 be used to eliminate redundant loads. OLD_OPS are the operands from the
|
|
|
2275 store stmt, and NEW_STMT is the new load which represents a load of the
|
|
|
2276 values stored. If DELINK_IMM_USES_P is specified, the immediate
|
|
|
2277 uses of this stmt will be de-linked. */
|
|
|
2278
|
|
|
2279 void
|
|
|
2280 create_ssa_artificial_load_stmt (gimple new_stmt, gimple old_stmt,
|
|
|
2281 bool delink_imm_uses_p)
|
|
|
2282 {
|
|
|
2283 tree op;
|
|
|
2284 ssa_op_iter iter;
|
|
|
2285 use_operand_p use_p;
|
|
|
2286 unsigned i;
|
|
|
2287
|
|
|
2288 gimple_set_modified (new_stmt, false);
|
|
|
2289
|
|
|
2290 /* Process NEW_STMT looking for operands. */
|
|
|
2291 start_ssa_stmt_operands ();
|
|
|
2292 parse_ssa_operands (new_stmt);
|
|
|
2293
|
|
|
2294 for (i = 0; VEC_iterate (tree, build_vuses, i, op); i++)
|
|
|
2295 if (TREE_CODE (op) != SSA_NAME)
|
|
|
2296 var_ann (op)->in_vuse_list = false;
|
|
|
2297
|
|
|
2298 for (i = 0; VEC_iterate (tree, build_vdefs, i, op); i++)
|
|
|
2299 if (TREE_CODE (op) != SSA_NAME)
|
|
|
2300 var_ann (op)->in_vdef_list = false;
|
|
|
2301
|
|
|
2302 /* Remove any virtual operands that were found. */
|
|
|
2303 VEC_truncate (tree, build_vdefs, 0);
|
|
|
2304 VEC_truncate (tree, build_vuses, 0);
|
|
|
2305
|
|
|
2306 /* Clear the loads and stores bitmaps. */
|
|
|
2307 bitmap_clear (build_loads);
|
|
|
2308 bitmap_clear (build_stores);
|
|
|
2309
|
|
|
2310 /* For each VDEF on the original statement, we want to create a
|
|
|
2311 VUSE of the VDEF result operand on the new statement. */
|
|
|
2312 FOR_EACH_SSA_TREE_OPERAND (op, old_stmt, iter, SSA_OP_VDEF)
|
|
|
2313 append_vuse (op);
|
|
|
2314
|
|
|
2315 finalize_ssa_stmt_operands (new_stmt);
|
|
|
2316
|
|
|
2317 /* All uses in this fake stmt must not be in the immediate use lists. */
|
|
|
2318 if (delink_imm_uses_p)
|
|
|
2319 FOR_EACH_SSA_USE_OPERAND (use_p, new_stmt, iter, SSA_OP_ALL_USES)
|
|
|
2320 delink_imm_use (use_p);
|
|
|
2321 }
|
|
|
2322
|
|
|
2323
|
|
|
2324 /* Swap operands EXP0 and EXP1 in statement STMT. No attempt is done
|
|
|
2325 to test the validity of the swap operation. */
|
|
|
2326
|
|
|
2327 void
|
|
|
2328 swap_tree_operands (gimple stmt, tree *exp0, tree *exp1)
|
|
|
2329 {
|
|
|
2330 tree op0, op1;
|
|
|
2331 op0 = *exp0;
|
|
|
2332 op1 = *exp1;
|
|
|
2333
|
|
|
2334 /* If the operand cache is active, attempt to preserve the relative
|
|
|
2335 positions of these two operands in their respective immediate use
|
|
|
2336 lists. */
|
|
|
2337 if (ssa_operands_active () && op0 != op1)
|
|
|
2338 {
|
|
|
2339 use_optype_p use0, use1, ptr;
|
|
|
2340 use0 = use1 = NULL;
|
|
|
2341
|
|
|
2342 /* Find the 2 operands in the cache, if they are there. */
|
|
|
2343 for (ptr = gimple_use_ops (stmt); ptr; ptr = ptr->next)
|
|
|
2344 if (USE_OP_PTR (ptr)->use == exp0)
|
|
|
2345 {
|
|
|
2346 use0 = ptr;
|
|
|
2347 break;
|
|
|
2348 }
|
|
|
2349
|
|
|
2350 for (ptr = gimple_use_ops (stmt); ptr; ptr = ptr->next)
|
|
|
2351 if (USE_OP_PTR (ptr)->use == exp1)
|
|
|
2352 {
|
|
|
2353 use1 = ptr;
|
|
|
2354 break;
|
|
|
2355 }
|
|
|
2356
|
|
|
2357 /* If both uses don't have operand entries, there isn't much we can do
|
|
|
2358 at this point. Presumably we don't need to worry about it. */
|
|
|
2359 if (use0 && use1)
|
|
|
2360 {
|
|
|
2361 tree *tmp = USE_OP_PTR (use1)->use;
|
|
|
2362 USE_OP_PTR (use1)->use = USE_OP_PTR (use0)->use;
|
|
|
2363 USE_OP_PTR (use0)->use = tmp;
|
|
|
2364 }
|
|
|
2365 }
|
|
|
2366
|
|
|
2367 /* Now swap the data. */
|
|
|
2368 *exp0 = op1;
|
|
|
2369 *exp1 = op0;
|
|
|
2370 }
|
|
|
2371
|
|
|
2372 /* Add the base address of REF to SET. */
|
|
|
2373
|
|
|
2374 void
|
|
|
2375 add_to_addressable_set (tree ref, bitmap *set)
|
|
|
2376 {
|
|
|
2377 tree var;
|
|
|
2378
|
|
|
2379 /* Note that it is *NOT OKAY* to use the target of a COMPONENT_REF
|
|
|
2380 as the only thing we take the address of. If VAR is a structure,
|
|
|
2381 taking the address of a field means that the whole structure may
|
|
|
2382 be referenced using pointer arithmetic. See PR 21407 and the
|
|
|
2383 ensuing mailing list discussion. */
|
|
|
2384 var = get_base_address (ref);
|
|
|
2385 if (var && SSA_VAR_P (var))
|
|
|
2386 {
|
|
|
2387 if (*set == NULL)
|
|
|
2388 *set = BITMAP_ALLOC (&operands_bitmap_obstack);
|
|
|
2389
|
|
|
2390 bitmap_set_bit (*set, DECL_UID (var));
|
|
|
2391 TREE_ADDRESSABLE (var) = 1;
|
|
|
2392 }
|
|
|
2393 }
|
|
|
2394
|
|
|
2395
|
|
|
2396 /* Add the base address of REF to the set of addresses taken by STMT.
|
|
|
2397 REF may be a single variable whose address has been taken or any
|
|
|
2398 other valid GIMPLE memory reference (structure reference, array,
|
|
|
2399 etc). If the base address of REF is a decl that has sub-variables,
|
|
|
2400 also add all of its sub-variables. */
|
|
|
2401
|
|
|
2402 void
|
|
|
2403 gimple_add_to_addresses_taken (gimple stmt, tree ref)
|
|
|
2404 {
|
|
|
2405 gcc_assert (gimple_has_ops (stmt));
|
|
|
2406 add_to_addressable_set (ref, gimple_addresses_taken_ptr (stmt));
|
|
|
2407 }
|
|
|
2408
|
|
|
2409
|
|
|
2410 /* Scan the immediate_use list for VAR making sure its linked properly.
|
|
|
2411 Return TRUE if there is a problem and emit an error message to F. */
|
|
|
2412
|
|
|
2413 bool
|
|
|
2414 verify_imm_links (FILE *f, tree var)
|
|
|
2415 {
|
|
|
2416 use_operand_p ptr, prev, list;
|
|
|
2417 int count;
|
|
|
2418
|
|
|
2419 gcc_assert (TREE_CODE (var) == SSA_NAME);
|
|
|
2420
|
|
|
2421 list = &(SSA_NAME_IMM_USE_NODE (var));
|
|
|
2422 gcc_assert (list->use == NULL);
|
|
|
2423
|
|
|
2424 if (list->prev == NULL)
|
|
|
2425 {
|
|
|
2426 gcc_assert (list->next == NULL);
|
|
|
2427 return false;
|
|
|
2428 }
|
|
|
2429
|
|
|
2430 prev = list;
|
|
|
2431 count = 0;
|
|
|
2432 for (ptr = list->next; ptr != list; )
|
|
|
2433 {
|
|
|
2434 if (prev != ptr->prev)
|
|
|
2435 goto error;
|
|
|
2436
|
|
|
2437 if (ptr->use == NULL)
|
|
|
2438 goto error; /* 2 roots, or SAFE guard node. */
|
|
|
2439 else if (*(ptr->use) != var)
|
|
|
2440 goto error;
|
|
|
2441
|
|
|
2442 prev = ptr;
|
|
|
2443 ptr = ptr->next;
|
|
|
2444
|
|
|
2445 /* Avoid infinite loops. 50,000,000 uses probably indicates a
|
|
|
2446 problem. */
|
|
|
2447 if (count++ > 50000000)
|
|
|
2448 goto error;
|
|
|
2449 }
|
|
|
2450
|
|
|
2451 /* Verify list in the other direction. */
|
|
|
2452 prev = list;
|
|
|
2453 for (ptr = list->prev; ptr != list; )
|
|
|
2454 {
|
|
|
2455 if (prev != ptr->next)
|
|
|
2456 goto error;
|
|
|
2457 prev = ptr;
|
|
|
2458 ptr = ptr->prev;
|
|
|
2459 if (count-- < 0)
|
|
|
2460 goto error;
|
|
|
2461 }
|
|
|
2462
|
|
|
2463 if (count != 0)
|
|
|
2464 goto error;
|
|
|
2465
|
|
|
2466 return false;
|
|
|
2467
|
|
|
2468 error:
|
|
|
2469 if (ptr->loc.stmt && gimple_modified_p (ptr->loc.stmt))
|
|
|
2470 {
|
|
|
2471 fprintf (f, " STMT MODIFIED. - <%p> ", (void *)ptr->loc.stmt);
|
|
|
2472 print_gimple_stmt (f, ptr->loc.stmt, 0, TDF_SLIM);
|
|
|
2473 }
|
|
|
2474 fprintf (f, " IMM ERROR : (use_p : tree - %p:%p)", (void *)ptr,
|
|
|
2475 (void *)ptr->use);
|
|
|
2476 print_generic_expr (f, USE_FROM_PTR (ptr), TDF_SLIM);
|
|
|
2477 fprintf(f, "\n");
|
|
|
2478 return true;
|
|
|
2479 }
|
|
|
2480
|
|
|
2481
|
|
|
2482 /* Dump all the immediate uses to FILE. */
|
|
|
2483
|
|
|
2484 void
|
|
|
2485 dump_immediate_uses_for (FILE *file, tree var)
|
|
|
2486 {
|
|
|
2487 imm_use_iterator iter;
|
|
|
2488 use_operand_p use_p;
|
|
|
2489
|
|
|
2490 gcc_assert (var && TREE_CODE (var) == SSA_NAME);
|
|
|
2491
|
|
|
2492 print_generic_expr (file, var, TDF_SLIM);
|
|
|
2493 fprintf (file, " : -->");
|
|
|
2494 if (has_zero_uses (var))
|
|
|
2495 fprintf (file, " no uses.\n");
|
|
|
2496 else
|
|
|
2497 if (has_single_use (var))
|
|
|
2498 fprintf (file, " single use.\n");
|
|
|
2499 else
|
|
|
2500 fprintf (file, "%d uses.\n", num_imm_uses (var));
|
|
|
2501
|
|
|
2502 FOR_EACH_IMM_USE_FAST (use_p, iter, var)
|
|
|
2503 {
|
|
|
2504 if (use_p->loc.stmt == NULL && use_p->use == NULL)
|
|
|
2505 fprintf (file, "***end of stmt iterator marker***\n");
|
|
|
2506 else
|
|
|
2507 if (!is_gimple_reg (USE_FROM_PTR (use_p)))
|
|
|
2508 print_gimple_stmt (file, USE_STMT (use_p), 0, TDF_VOPS|TDF_MEMSYMS);
|
|
|
2509 else
|
|
|
2510 print_gimple_stmt (file, USE_STMT (use_p), 0, TDF_SLIM);
|
|
|
2511 }
|
|
|
2512 fprintf(file, "\n");
|
|
|
2513 }
|
|
|
2514
|
|
|
2515
|
|
|
2516 /* Dump all the immediate uses to FILE. */
|
|
|
2517
|
|
|
2518 void
|
|
|
2519 dump_immediate_uses (FILE *file)
|
|
|
2520 {
|
|
|
2521 tree var;
|
|
|
2522 unsigned int x;
|
|
|
2523
|
|
|
2524 fprintf (file, "Immediate_uses: \n\n");
|
|
|
2525 for (x = 1; x < num_ssa_names; x++)
|
|
|
2526 {
|
|
|
2527 var = ssa_name(x);
|
|
|
2528 if (!var)
|
|
|
2529 continue;
|
|
|
2530 dump_immediate_uses_for (file, var);
|
|
|
2531 }
|
|
|
2532 }
|
|
|
2533
|
|
|
2534
|
|
|
2535 /* Dump def-use edges on stderr. */
|
|
|
2536
|
|
|
2537 void
|
|
|
2538 debug_immediate_uses (void)
|
|
|
2539 {
|
|
|
2540 dump_immediate_uses (stderr);
|
|
|
2541 }
|
|
|
2542
|
|
|
2543
|
|
|
2544 /* Dump def-use edges on stderr. */
|
|
|
2545
|
|
|
2546 void
|
|
|
2547 debug_immediate_uses_for (tree var)
|
|
|
2548 {
|
|
|
2549 dump_immediate_uses_for (stderr, var);
|
|
|
2550 }
|
|
|
2551
|
|
|
2552
|
|
|
2553 /* Create a new change buffer for the statement pointed by STMT_P and
|
|
|
2554 push the buffer into SCB_STACK. Each change buffer
|
|
|
2555 records state information needed to determine what changed in the
|
|
|
2556 statement. Mainly, this keeps track of symbols that may need to be
|
|
|
2557 put into SSA form, SSA name replacements and other information
|
|
|
2558 needed to keep the SSA form up to date. */
|
|
|
2559
|
|
|
2560 void
|
|
|
2561 push_stmt_changes (gimple *stmt_p)
|
|
|
2562 {
|
|
|
2563 gimple stmt;
|
|
|
2564 scb_t buf;
|
|
|
2565
|
|
|
2566 stmt = *stmt_p;
|
|
|
2567
|
|
|
2568 /* It makes no sense to keep track of PHI nodes. */
|
|
|
2569 if (gimple_code (stmt) == GIMPLE_PHI)
|
|
|
2570 return;
|
|
|
2571
|
|
|
2572 buf = XNEW (struct scb_d);
|
|
|
2573 memset (buf, 0, sizeof *buf);
|
|
|
2574
|
|
|
2575 buf->stmt_p = stmt_p;
|
|
|
2576
|
|
|
2577 if (gimple_references_memory_p (stmt))
|
|
|
2578 {
|
|
|
2579 tree op;
|
|
|
2580 ssa_op_iter i;
|
|
|
2581
|
|
|
2582 FOR_EACH_SSA_TREE_OPERAND (op, stmt, i, SSA_OP_VUSE)
|
|
|
2583 {
|
|
|
2584 tree sym = TREE_CODE (op) == SSA_NAME ? SSA_NAME_VAR (op) : op;
|
|
|
2585 if (buf->loads == NULL)
|
|
|
2586 buf->loads = BITMAP_ALLOC (NULL);
|
|
|
2587 bitmap_set_bit (buf->loads, DECL_UID (sym));
|
|
|
2588 }
|
|
|
2589
|
|
|
2590 FOR_EACH_SSA_TREE_OPERAND (op, stmt, i, SSA_OP_VDEF)
|
|
|
2591 {
|
|
|
2592 tree sym = TREE_CODE (op) == SSA_NAME ? SSA_NAME_VAR (op) : op;
|
|
|
2593 if (buf->stores == NULL)
|
|
|
2594 buf->stores = BITMAP_ALLOC (NULL);
|
|
|
2595 bitmap_set_bit (buf->stores, DECL_UID (sym));
|
|
|
2596 }
|
|
|
2597 }
|
|
|
2598
|
|
|
2599 VEC_safe_push (scb_t, heap, scb_stack, buf);
|
|
|
2600 }
|
|
|
2601
|
|
|
2602
|
|
|
2603 /* Given two sets S1 and S2, mark the symbols that differ in S1 and S2
|
|
|
2604 for renaming. The set to mark for renaming is (S1 & ~S2) | (S2 & ~S1). */
|
|
|
2605
|
|
|
2606 static void
|
|
|
2607 mark_difference_for_renaming (bitmap s1, bitmap s2)
|
|
|
2608 {
|
|
|
2609 if (s1 == NULL && s2 == NULL)
|
|
|
2610 return;
|
|
|
2611
|
|
|
2612 if (s1 && s2 == NULL)
|
|
|
2613 mark_set_for_renaming (s1);
|
|
|
2614 else if (s1 == NULL && s2)
|
|
|
2615 mark_set_for_renaming (s2);
|
|
|
2616 else if (!bitmap_equal_p (s1, s2))
|
|
|
2617 {
|
|
|
2618 bitmap t1 = BITMAP_ALLOC (NULL);
|
|
|
2619 bitmap_xor (t1, s1, s2);
|
|
|
2620 mark_set_for_renaming (t1);
|
|
|
2621 BITMAP_FREE (t1);
|
|
|
2622 }
|
|
|
2623 }
|
|
|
2624
|
|
|
2625
|
|
|
2626 /* Pop the top SCB from SCB_STACK and act on the differences between
|
|
|
2627 what was recorded by push_stmt_changes and the current state of
|
|
|
2628 the statement. */
|
|
|
2629
|
|
|
2630 void
|
|
|
2631 pop_stmt_changes (gimple *stmt_p)
|
|
|
2632 {
|
|
|
2633 tree op;
|
|
|
2634 gimple stmt;
|
|
|
2635 ssa_op_iter iter;
|
|
|
2636 bitmap loads, stores;
|
|
|
2637 scb_t buf;
|
|
|
2638
|
|
|
2639 stmt = *stmt_p;
|
|
|
2640
|
|
|
2641 /* It makes no sense to keep track of PHI nodes. */
|
|
|
2642 if (gimple_code (stmt) == GIMPLE_PHI)
|
|
|
2643 return;
|
|
|
2644
|
|
|
2645 buf = VEC_pop (scb_t, scb_stack);
|
|
|
2646 gcc_assert (stmt_p == buf->stmt_p);
|
|
|
2647
|
|
|
2648 /* Force an operand re-scan on the statement and mark any newly
|
|
|
2649 exposed variables. */
|
|
|
2650 update_stmt (stmt);
|
|
|
2651
|
|
|
2652 /* Determine whether any memory symbols need to be renamed. If the
|
|
|
2653 sets of loads and stores are different after the statement is
|
|
|
2654 modified, then the affected symbols need to be renamed.
|
|
|
2655
|
|
|
2656 Note that it may be possible for the statement to not reference
|
|
|
2657 memory anymore, but we still need to act on the differences in
|
|
|
2658 the sets of symbols. */
|
|
|
2659 loads = stores = NULL;
|
|
|
2660 if (gimple_references_memory_p (stmt))
|
|
|
2661 {
|
|
|
2662 tree op;
|
|
|
2663 ssa_op_iter i;
|
|
|
2664
|
|
|
2665 FOR_EACH_SSA_TREE_OPERAND (op, stmt, i, SSA_OP_VUSE)
|
|
|
2666 {
|
|
|
2667 tree sym = TREE_CODE (op) == SSA_NAME ? SSA_NAME_VAR (op) : op;
|
|
|
2668 if (loads == NULL)
|
|
|
2669 loads = BITMAP_ALLOC (NULL);
|
|
|
2670 bitmap_set_bit (loads, DECL_UID (sym));
|
|
|
2671 }
|
|
|
2672
|
|
|
2673 FOR_EACH_SSA_TREE_OPERAND (op, stmt, i, SSA_OP_VDEF)
|
|
|
2674 {
|
|
|
2675 tree sym = TREE_CODE (op) == SSA_NAME ? SSA_NAME_VAR (op) : op;
|
|
|
2676 if (stores == NULL)
|
|
|
2677 stores = BITMAP_ALLOC (NULL);
|
|
|
2678 bitmap_set_bit (stores, DECL_UID (sym));
|
|
|
2679 }
|
|
|
2680 }
|
|
|
2681
|
|
|
2682 /* If LOADS is different from BUF->LOADS, the affected
|
|
|
2683 symbols need to be marked for renaming. */
|
|
|
2684 mark_difference_for_renaming (loads, buf->loads);
|
|
|
2685
|
|
|
2686 /* Similarly for STORES and BUF->STORES. */
|
|
|
2687 mark_difference_for_renaming (stores, buf->stores);
|
|
|
2688
|
|
|
2689 /* Mark all the naked GIMPLE register operands for renaming. */
|
|
|
2690 FOR_EACH_SSA_TREE_OPERAND (op, stmt, iter, SSA_OP_DEF|SSA_OP_USE)
|
|
|
2691 if (DECL_P (op))
|
|
|
2692 mark_sym_for_renaming (op);
|
|
|
2693
|
|
|
2694 /* FIXME, need to add more finalizers here. Cleanup EH info,
|
|
|
2695 recompute invariants for address expressions, add
|
|
|
2696 SSA replacement mappings, etc. For instance, given
|
|
|
2697 testsuite/gcc.c-torture/compile/pr16808.c, we fold a statement of
|
|
|
2698 the form:
|
|
|
2699
|
|
|
2700 # SMT.4_20 = VDEF <SMT.4_16>
|
|
|
2701 D.1576_11 = 1.0e+0;
|
|
|
2702
|
|
|
2703 So, the VDEF will disappear, but instead of marking SMT.4 for
|
|
|
2704 renaming it would be far more efficient to establish a
|
|
|
2705 replacement mapping that would replace every reference of
|
|
|
2706 SMT.4_20 with SMT.4_16. */
|
|
|
2707
|
|
|
2708 /* Free memory used by the buffer. */
|
|
|
2709 BITMAP_FREE (buf->loads);
|
|
|
2710 BITMAP_FREE (buf->stores);
|
|
|
2711 BITMAP_FREE (loads);
|
|
|
2712 BITMAP_FREE (stores);
|
|
|
2713 buf->stmt_p = NULL;
|
|
|
2714 free (buf);
|
|
|
2715 }
|
|
|
2716
|
|
|
2717
|
|
|
2718 /* Discard the topmost change buffer from SCB_STACK. This is useful
|
|
|
2719 when the caller realized that it did not actually modified the
|
|
|
2720 statement. It avoids the expensive operand re-scan. */
|
|
|
2721
|
|
|
2722 void
|
|
|
2723 discard_stmt_changes (gimple *stmt_p)
|
|
|
2724 {
|
|
|
2725 scb_t buf;
|
|
|
2726 gimple stmt;
|
|
|
2727
|
|
|
2728 /* It makes no sense to keep track of PHI nodes. */
|
|
|
2729 stmt = *stmt_p;
|
|
|
2730 if (gimple_code (stmt) == GIMPLE_PHI)
|
|
|
2731 return;
|
|
|
2732
|
|
|
2733 buf = VEC_pop (scb_t, scb_stack);
|
|
|
2734 gcc_assert (stmt_p == buf->stmt_p);
|
|
|
2735
|
|
|
2736 /* Free memory used by the buffer. */
|
|
|
2737 BITMAP_FREE (buf->loads);
|
|
|
2738 BITMAP_FREE (buf->stores);
|
|
|
2739 buf->stmt_p = NULL;
|
|
|
2740 free (buf);
|
|
|
2741 }
|
