OSDN Git Service

c11360d94acfc411cf1bfdd23623b3d5a1db90f0
[pf3gnuchains/gcc-fork.git] / gcc / tree-ssa-operands.c
1 /* SSA operands management for trees.
2    Copyright (C) 2003 Free Software Foundation, Inc.
3
4 This file is part of GCC.
5
6 GCC is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
9 any later version.
10
11 GCC is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14 GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with GCC; see the file COPYING.  If not, write to
18 the Free Software Foundation, 59 Temple Place - Suite 330,
19 Boston, MA 02111-1307, USA.  */
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
35
36 /* This file contains the code required to mnage the operands cache of the 
37    SSA optimizer.  For every stmt, we maintain an operand cache in the stmt 
38    annotation.  This cache contains operands that will be of interets to 
39    optimizers and other passes wishing to manipulate the IL. 
40
41    The operand type are broken up into REAL and VIRTUAL operands.  The real 
42    operands are represented as pointers into the stmt's operand tree.  Thus 
43    any manipulation of the real operands will be reflected in the actual tree.
44    Virtual operands are represented solely in the cache, although the base 
45    variable for the SSA_NAME may, or may not occur in the stmt's tree.  
46    Manipulation of the virtual operands will not be reflected in the stmt tree.
47
48    The routines in this file are concerned with creating this operand cache 
49    from a stmt tree.
50
51    get_stmt_operands() in the primary entry point. 
52
53    The operand tree is the parsed by the various get_* routines which look 
54    through the stmt tree for the occurrence of operands which may be of 
55    interest, and calls are made to the append_* routines whenever one is 
56    found.  There are 5 of these routines, each representing one of the 
57    5 types of operands. Defs, Uses, Virtual Uses, Virtual May Defs, and 
58    Virtual Must Defs.
59
60    The append_* routines check for duplication, and simply keep a list of 
61    unique objects for each operand type in the build_* extendable vectors.
62
63    Once the stmt tree is completely parsed, the finalize_ssa_operands() 
64    routine is called, which proceeds to perform the finalization routine 
65    on each of the 5 operand vectors which have been built up.
66
67    If the stmt had a previous operand cache, the finalization routines 
68    attempt to match up the new operands with the old ones.  If its a perfect 
69    match, the old vector is simply reused.  If it isn't a perfect match, then 
70    a new vector is created and the new operands are placed there.  For 
71    virtual operands, if the previous cache had SSA_NAME version of a 
72    variable, and that same variable occurs in the same operands cache, then 
73    the new cache vector will also get the same SSA_NAME.
74
75   ie, if a stmt had a VUSE of 'a_5', and 'a' occurs in the new operand 
76   vector for VUSE, then the new vector will also be modified such that 
77   it contains 'a_5' rather than 'a'.
78
79 */
80
81
82 /* Flags to describe operand properties in get_stmt_operands and helpers.  */
83
84 /* By default, operands are loaded.  */
85 #define opf_none        0
86
87 /* Operand is the target of an assignment expression or a 
88    call-clobbered variable  */
89 #define opf_is_def      (1 << 0)
90
91 /* Operand is the target of an assignment expression.  */
92 #define opf_kill_def    (1 << 1)
93
94 /* No virtual operands should be created in the expression.  This is used
95    when traversing ADDR_EXPR nodes which have different semantics than
96    other expressions.  Inside an ADDR_EXPR node, the only operands that we
97    need to consider are indices into arrays.  For instance, &a.b[i] should
98    generate a USE of 'i' but it should not generate a VUSE for 'a' nor a
99    VUSE for 'b'.  */
100 #define opf_no_vops     (1 << 2)
101
102 /* Array for building all the def operands.  */
103 static GTY (()) varray_type build_defs;
104
105 /* Array for building all the use operands.  */
106 static GTY (()) varray_type build_uses;
107
108 /* Array for building all the v_may_def operands.  */
109 static GTY (()) varray_type build_v_may_defs;
110
111 /* Array for building all the vuse operands.  */
112 static GTY (()) varray_type build_vuses;
113
114 /* Array for building all the v_must_def operands.  */
115 static GTY (()) varray_type build_v_must_defs;
116
117
118 #ifdef ENABLE_CHECKING
119 /* Used to make sure operand construction is working on the proper stmt.  */
120 tree check_build_stmt;
121 #endif
122
123 def_operand_p NULL_DEF_OPERAND_P = { NULL };
124 use_operand_p NULL_USE_OPERAND_P = { NULL };
125
126 static void note_addressable (tree, stmt_ann_t);
127 static void get_expr_operands (tree, tree *, int);
128 static void get_asm_expr_operands (tree);
129 static void get_indirect_ref_operands (tree, tree, int);
130 static void get_call_expr_operands (tree, tree);
131 static inline void append_def (tree *);
132 static inline void append_use (tree *);
133 static void append_v_may_def (tree);
134 static void append_v_must_def (tree);
135 static void add_call_clobber_ops (tree);
136 static void add_call_read_ops (tree);
137 static void add_stmt_operand (tree *, tree, int);
138
139 /* Return a vector of contiguous memory for NUM def operands.  */
140
141 static inline def_optype
142 allocate_def_optype (unsigned num)
143 {
144   def_optype def_ops;
145   unsigned size;
146   size = sizeof (struct def_optype_d) + sizeof (tree *) * (num - 1);
147   def_ops =  ggc_alloc (size);
148   def_ops->num_defs = num;
149   return def_ops;
150 }
151
152
153 /* Return a vector of contiguous memory for NUM use operands.  */
154
155 static inline use_optype
156 allocate_use_optype (unsigned num)
157 {
158   use_optype use_ops;
159   unsigned size;
160   size = sizeof (struct use_optype_d) + sizeof (tree *) * (num - 1);
161   use_ops =  ggc_alloc (size);
162   use_ops->num_uses = num;
163   return use_ops;
164 }
165
166
167 /* Return a vector of contiguous memory for NUM v_may_def operands.  */
168
169 static inline v_may_def_optype
170 allocate_v_may_def_optype (unsigned num)
171 {
172   v_may_def_optype v_may_def_ops;
173   unsigned size;
174   size = sizeof (struct v_may_def_optype_d) 
175            + sizeof (v_may_def_operand_type_t) * (num - 1);
176   v_may_def_ops =  ggc_alloc (size);
177   v_may_def_ops->num_v_may_defs = num;
178   return v_may_def_ops;
179 }
180
181
182 /* Return a vector of contiguous memory for NUM v_use operands.  */
183
184 static inline vuse_optype
185 allocate_vuse_optype (unsigned num)
186 {
187   vuse_optype vuse_ops;
188   unsigned size;
189   size = sizeof (struct vuse_optype_d) + sizeof (tree) * (num - 1);
190   vuse_ops =  ggc_alloc (size);
191   vuse_ops->num_vuses = num;
192   return vuse_ops;
193 }
194
195
196 /* Return a vector of contiguous memory for NUM v_must_def operands.  */
197
198 static inline v_must_def_optype
199 allocate_v_must_def_optype (unsigned num)
200 {
201   v_must_def_optype v_must_def_ops;
202   unsigned size;
203   size = sizeof (struct v_must_def_optype_d) + sizeof (tree) * (num - 1);
204   v_must_def_ops =  ggc_alloc (size);
205   v_must_def_ops->num_v_must_defs = num;
206   return v_must_def_ops;
207 }
208
209
210 /* Free memory for USES.  */
211
212 static inline void
213 free_uses (use_optype *uses)
214 {
215   if (*uses)
216     {
217       ggc_free (*uses);
218       *uses = NULL;
219     }
220 }
221
222
223 /* Free memory for DEFS.  */
224
225 static inline void
226 free_defs (def_optype *defs)
227 {
228   if (*defs)
229     {
230       ggc_free (*defs);
231       *defs = NULL;
232     }
233 }
234
235
236 /* Free memory for VUSES.  */
237
238 static inline void
239 free_vuses (vuse_optype *vuses)
240 {
241   if (*vuses)
242     {
243       ggc_free (*vuses);
244       *vuses = NULL;
245     }
246 }
247
248
249 /* Free memory for V_MAY_DEFS.  */
250
251 static inline void
252 free_v_may_defs (v_may_def_optype *v_may_defs)
253 {
254   if (*v_may_defs)
255     {
256       ggc_free (*v_may_defs);
257       *v_may_defs = NULL;
258     }
259 }
260
261
262 /* Free memory for V_MUST_DEFS.  */
263
264 static inline void
265 free_v_must_defs (v_must_def_optype *v_must_defs)
266 {
267   if (*v_must_defs)
268     {
269       ggc_free (*v_must_defs);
270       *v_must_defs = NULL;
271     }
272 }
273
274
275 /* Initialize the operand cache routines.  */
276
277 void
278 init_ssa_operands (void)
279 {
280   VARRAY_TREE_PTR_INIT (build_defs, 5, "build defs");
281   VARRAY_TREE_PTR_INIT (build_uses, 10, "build uses");
282   VARRAY_TREE_INIT (build_v_may_defs, 10, "build v_may_defs");
283   VARRAY_TREE_INIT (build_vuses, 10, "build vuses");
284   VARRAY_TREE_INIT (build_v_must_defs, 10, "build v_must_defs");
285 }
286
287
288 /* Dispose of anything required by the operand routines.  */
289
290 void
291 fini_ssa_operands (void)
292 {
293   ggc_free (build_defs);
294   ggc_free (build_uses);
295   ggc_free (build_v_may_defs);
296   ggc_free (build_vuses);
297   ggc_free (build_v_must_defs);
298   build_defs = NULL;
299   build_uses = NULL;
300   build_v_may_defs = NULL;
301   build_vuses = NULL;
302   build_v_must_defs = NULL;
303 }
304
305
306 /* All the finalize_ssa_* routines do the work required to turn the build_
307    VARRAY into an operand_vector of the appropriate type.  The original vector,
308    if any, is passed in for comparison and virtual SSA_NAME reuse.  If the
309    old vector is reused, the pointer passed in is set to NULL so that 
310    the memory is not freed when the old operands are freed.  */
311
312 /* Return a new def operand vector for STMT, comparing to OLD_OPS_P.  */
313
314 static def_optype
315 finalize_ssa_defs (def_optype *old_ops_p, tree stmt ATTRIBUTE_UNUSED)
316 {
317   unsigned num, x;
318   def_optype def_ops, old_ops;
319   bool build_diff;
320
321   num = VARRAY_ACTIVE_SIZE (build_defs);
322   if (num == 0)
323     return NULL;
324
325 #ifdef ENABLE_CHECKING
326   /* There should only be a single real definition per assignment.  */
327   if (TREE_CODE (stmt) == MODIFY_EXPR && num > 1)
328     abort ();
329 #endif
330
331   old_ops = *old_ops_p;
332
333   /* Compare old vector and new array.  */
334   build_diff = true;
335   if (old_ops && old_ops->num_defs == num)
336     {
337       build_diff = false;
338       for (x = 0; x < num; x++)
339         if (old_ops->defs[x].def != VARRAY_TREE_PTR (build_defs, x))
340           {
341             build_diff = true;
342             break;
343           }
344     }
345
346   if (!build_diff)
347     {
348       def_ops = old_ops;
349       *old_ops_p = NULL;
350     }
351   else
352     {
353       def_ops = allocate_def_optype (num);
354       for (x = 0; x < num ; x++)
355         def_ops->defs[x].def = VARRAY_TREE_PTR (build_defs, x);
356     }
357
358   VARRAY_POP_ALL (build_defs);
359
360   return def_ops;
361 }
362
363
364 /* Return a new use operand vector for STMT, comparing to OLD_OPS_P.  */
365
366 static use_optype
367 finalize_ssa_uses (use_optype *old_ops_p, tree stmt ATTRIBUTE_UNUSED)
368 {
369   unsigned num, x;
370   use_optype use_ops, old_ops;
371   bool build_diff;
372
373   num = VARRAY_ACTIVE_SIZE (build_uses);
374   if (num == 0)
375     return NULL;
376
377 #ifdef ENABLE_CHECKING
378   {
379     unsigned x;
380     /* If the pointer to the operand is the statement itself, something is
381        wrong.  It means that we are pointing to a local variable (the 
382        initial call to get_stmt_operands does not pass a pointer to a 
383        statement).  */
384     for (x = 0; x < num; x++)
385       if (*(VARRAY_TREE_PTR (build_uses, x)) == stmt)
386         abort ();
387   }
388 #endif
389   old_ops = *old_ops_p;
390
391   /* Check if the old vector and the new array are the same.  */
392   build_diff = true;
393   if (old_ops && old_ops->num_uses == num)
394     {
395       build_diff = false;
396       for (x = 0; x < num; x++)
397         if (old_ops->uses[x].use != VARRAY_TREE_PTR (build_uses, x))
398           {
399             build_diff = true;
400             break;
401           }
402     }
403
404   if (!build_diff)
405     {
406       use_ops = old_ops;
407       *old_ops_p = NULL;
408     }
409   else
410     {
411       use_ops = allocate_use_optype (num);
412       for (x = 0; x < num ; x++)
413         use_ops->uses[x].use = VARRAY_TREE_PTR (build_uses, x);
414     }
415   VARRAY_POP_ALL (build_uses);
416
417   return use_ops;
418 }
419
420
421 /* Return a new v_may_def operand vector for STMT, comparing to OLD_OPS_P.  */
422
423 static v_may_def_optype
424 finalize_ssa_v_may_defs (v_may_def_optype *old_ops_p)
425 {
426   unsigned num, x, i, old_num;
427   v_may_def_optype v_may_def_ops, old_ops;
428   tree result, var;
429   bool build_diff;
430
431   num = VARRAY_ACTIVE_SIZE (build_v_may_defs);
432   if (num == 0)
433     return NULL;
434
435   old_ops = *old_ops_p;
436
437   /* Check if the old vector and the new array are the same.  */
438   build_diff = true;
439   if (old_ops && old_ops->num_v_may_defs == num)
440     {
441       old_num = num;
442       build_diff = false;
443       for (x = 0; x < num; x++)
444         {
445           var = old_ops->v_may_defs[x].def;
446           if (TREE_CODE (var) == SSA_NAME)
447             var = SSA_NAME_VAR (var);
448           if (var != VARRAY_TREE (build_v_may_defs, x))
449             {
450               build_diff = true;
451               break;
452             }
453         }
454     }
455   else
456     old_num = (old_ops ? old_ops->num_v_may_defs : 0);
457
458   if (!build_diff)
459     {
460       v_may_def_ops = old_ops;
461       *old_ops_p = NULL;
462     }
463   else
464     {
465       v_may_def_ops = allocate_v_may_def_optype (num);
466       for (x = 0; x < num; x++)
467         {
468           var = VARRAY_TREE (build_v_may_defs, x);
469           /* Look for VAR in the old operands vector.  */
470           for (i = 0; i < old_num; i++)
471             {
472               result = old_ops->v_may_defs[i].def;
473               if (TREE_CODE (result) == SSA_NAME)
474                 result = SSA_NAME_VAR (result);
475               if (result == var)
476                 {
477                   v_may_def_ops->v_may_defs[x] = old_ops->v_may_defs[i];
478                   break;
479                 }
480             }
481           if (i == old_num)
482             {
483               v_may_def_ops->v_may_defs[x].def = var;
484               v_may_def_ops->v_may_defs[x].use = var;
485             }
486         }
487     }
488
489   /* Empty the V_MAY_DEF build vector after VUSES have been processed.  */
490
491   return v_may_def_ops;
492 }
493
494
495 /* Return a new vuse operand vector, comparing to OLD_OPS_P.  */
496
497 static vuse_optype
498 finalize_ssa_vuses (vuse_optype *old_ops_p)
499 {
500   unsigned num, x, i, num_v_may_defs, old_num;
501   vuse_optype vuse_ops, old_ops;
502   bool build_diff;
503
504   num = VARRAY_ACTIVE_SIZE (build_vuses);
505   if (num == 0)
506     {
507       VARRAY_POP_ALL (build_v_may_defs);
508       return NULL;
509     }
510
511   /* Remove superfluous VUSE operands.  If the statement already has a
512    V_MAY_DEF operation for a variable 'a', then a VUSE for 'a' is not
513    needed because V_MAY_DEFs imply a VUSE of the variable.  For instance,
514    suppose that variable 'a' is aliased:
515
516               # VUSE <a_2>
517               # a_3 = V_MAY_DEF <a_2>
518               a = a + 1;
519
520   The VUSE <a_2> is superfluous because it is implied by the V_MAY_DEF
521   operation.  */
522
523   num_v_may_defs = VARRAY_ACTIVE_SIZE (build_v_may_defs);
524
525   if (num_v_may_defs > 0)
526     {
527       size_t i, j;
528       tree vuse;
529       for (i = 0; i < VARRAY_ACTIVE_SIZE (build_vuses); i++)
530         {
531           vuse = VARRAY_TREE (build_vuses, i);
532           for (j = 0; j < num_v_may_defs; j++)
533             {
534               if (vuse == VARRAY_TREE (build_v_may_defs, j))
535                 break;
536             }
537
538           /* If we found a useless VUSE operand, remove it from the
539              operand array by replacing it with the last active element
540              in the operand array (unless the useless VUSE was the
541              last operand, in which case we simply remove it.  */
542           if (j != num_v_may_defs)
543             {
544               if (i != VARRAY_ACTIVE_SIZE (build_vuses) - 1)
545                 {
546                   VARRAY_TREE (build_vuses, i)
547                     = VARRAY_TREE (build_vuses,
548                                    VARRAY_ACTIVE_SIZE (build_vuses) - 1);
549                 }
550               VARRAY_POP (build_vuses);
551
552               /* We want to rescan the element at this index, unless
553                  this was the last element, in which case the loop
554                  terminates.  */
555               i--;
556             }
557         }
558     }
559
560   num = VARRAY_ACTIVE_SIZE (build_vuses);
561   /* We could have reduced the size to zero now, however.  */
562   if (num == 0)
563     {
564       VARRAY_POP_ALL (build_v_may_defs);
565       return NULL;
566     }
567
568   old_ops = *old_ops_p;
569
570   /* Determine whether vuses is the same as the old vector.  */
571   build_diff = true;
572   if (old_ops && old_ops->num_vuses == num)
573     {
574       old_num = num;
575       build_diff = false;
576       for (x = 0; x < num ; x++)
577         {
578           tree v;
579           v = old_ops->vuses[x];
580           if (TREE_CODE (v) == SSA_NAME)
581             v = SSA_NAME_VAR (v);
582           if (v != VARRAY_TREE (build_vuses, x))
583             {
584               build_diff = true;
585               break;
586             }
587         }
588     }
589   else
590     old_num = (old_ops ? old_ops->num_vuses : 0);
591
592   if (!build_diff)
593     {
594       vuse_ops = old_ops;
595       *old_ops_p = NULL;
596     }
597   else
598     {
599       vuse_ops = allocate_vuse_optype (num);
600       for (x = 0; x < num; x++)
601         {
602           tree result, var = VARRAY_TREE (build_vuses, x);
603           /* Look for VAR in the old vector, and use that SSA_NAME.  */
604           for (i = 0; i < old_num; i++)
605             {
606               result = old_ops->vuses[i];
607               if (TREE_CODE (result) == SSA_NAME)
608                 result = SSA_NAME_VAR (result);
609               if (result == var)
610                 {
611                   vuse_ops->vuses[x] = old_ops->vuses[i];
612                   break;
613                 }
614             }
615           if (i == old_num)
616             vuse_ops->vuses[x] = var;
617         }
618     }
619
620   /* The v_may_def build vector wasn't freed because we needed it here.
621      Free it now with the vuses build vector.  */
622   VARRAY_POP_ALL (build_vuses);
623   VARRAY_POP_ALL (build_v_may_defs);
624
625   return vuse_ops;
626 }
627
628 /* Return a new v_must_def operand vector for STMT, comparing to OLD_OPS_P.  */
629
630 static v_must_def_optype
631 finalize_ssa_v_must_defs (v_must_def_optype *old_ops_p, 
632                           tree stmt ATTRIBUTE_UNUSED)
633 {
634   unsigned num, x, i, old_num = 0;
635   v_must_def_optype v_must_def_ops, old_ops;
636   bool build_diff;
637
638   num = VARRAY_ACTIVE_SIZE (build_v_must_defs);
639   if (num == 0)
640     return NULL;
641
642 #ifdef ENABLE_CHECKING
643   /* There should only be a single V_MUST_DEF per assignment.  */
644   if (TREE_CODE (stmt) == MODIFY_EXPR && num > 1)
645     abort ();
646 #endif
647
648   old_ops = *old_ops_p;
649
650   /* Check if the old vector and the new array are the same.  */
651   build_diff = true;
652   if (old_ops && old_ops->num_v_must_defs == num)
653     {
654       old_num = num;
655       build_diff = false;
656       for (x = 0; x < num; x++)
657         {
658           tree var = old_ops->v_must_defs[x];
659           if (TREE_CODE (var) == SSA_NAME)
660             var = SSA_NAME_VAR (var);
661           if (var != VARRAY_TREE (build_v_must_defs, x))
662             {
663               build_diff = true;
664               break;
665             }
666         }
667     }
668   else
669     old_num = (old_ops ? old_ops->num_v_must_defs : 0);
670
671   if (!build_diff)
672     {
673       v_must_def_ops = old_ops;
674       *old_ops_p = NULL;
675     }
676   else
677     {
678       v_must_def_ops = allocate_v_must_def_optype (num);
679       for (x = 0; x < num ; x++)
680         {
681           tree result, var = VARRAY_TREE (build_v_must_defs, x);
682           /* Look for VAR in the original vector.  */
683           for (i = 0; i < old_num; i++)
684             {
685               result = old_ops->v_must_defs[i];
686               if (TREE_CODE (result) == SSA_NAME)
687                 result = SSA_NAME_VAR (result);
688               if (result == var)
689                 {
690                   v_must_def_ops->v_must_defs[x] = old_ops->v_must_defs[i];
691                   break;
692                 }
693             }
694           if (i == old_num)
695             v_must_def_ops->v_must_defs[x] = var;
696         }
697     }
698   VARRAY_POP_ALL (build_v_must_defs);
699
700   return v_must_def_ops;
701 }
702
703
704 /* Finalize all the build vectors, fill the new ones into INFO.  */
705
706 static inline void
707 finalize_ssa_stmt_operands (tree stmt, stmt_operands_p old_ops, 
708                             stmt_operands_p new_ops)
709 {
710   new_ops->def_ops = finalize_ssa_defs (&(old_ops->def_ops), stmt);
711   new_ops->use_ops = finalize_ssa_uses (&(old_ops->use_ops), stmt);
712   new_ops->v_must_def_ops 
713     = finalize_ssa_v_must_defs (&(old_ops->v_must_def_ops), stmt);
714   new_ops->v_may_def_ops = finalize_ssa_v_may_defs (&(old_ops->v_may_def_ops));
715   new_ops->vuse_ops = finalize_ssa_vuses (&(old_ops->vuse_ops));
716 }
717
718
719 /* Start the process of building up operands vectors in INFO.  */
720
721 static inline void
722 start_ssa_stmt_operands (void)
723 {
724 #ifdef ENABLE_CHECKING
725   if (VARRAY_ACTIVE_SIZE (build_defs) > 0 
726       || VARRAY_ACTIVE_SIZE (build_uses) > 0
727       || VARRAY_ACTIVE_SIZE (build_vuses) > 0
728       || VARRAY_ACTIVE_SIZE (build_v_may_defs) > 0
729       || VARRAY_ACTIVE_SIZE (build_v_must_defs) > 0)
730     abort ();
731 #endif
732 }
733
734
735 /* Add DEF_P to the list of pointers to operands.  */
736
737 static inline void
738 append_def (tree *def_p)
739 {
740   VARRAY_PUSH_TREE_PTR (build_defs, def_p);
741 }
742
743
744 /* Add USE_P to the list of pointers to operands.  */
745
746 static inline void
747 append_use (tree *use_p)
748 {
749   VARRAY_PUSH_TREE_PTR (build_uses, use_p);
750 }
751
752
753 /* Add a new virtual may def for variable VAR to the build array.  */
754
755 static inline void
756 append_v_may_def (tree var)
757 {
758   unsigned i;
759
760   /* Don't allow duplicate entries.  */
761   for (i = 0; i < VARRAY_ACTIVE_SIZE (build_v_may_defs); i++)
762     if (var == VARRAY_TREE (build_v_may_defs, i))
763       return;
764
765   VARRAY_PUSH_TREE (build_v_may_defs, var);
766 }
767
768
769 /* Add VAR to the list of virtual uses.  */
770
771 static inline void
772 append_vuse (tree var)
773 {
774   size_t i;
775
776   /* Don't allow duplicate entries.  */
777   for (i = 0; i < VARRAY_ACTIVE_SIZE (build_vuses); i++)
778     if (var == VARRAY_TREE (build_vuses, i))
779       return;
780
781   VARRAY_PUSH_TREE (build_vuses, var);
782 }
783
784
785 /* Add VAR to the list of virtual must definitions for INFO.  */
786
787 static inline void
788 append_v_must_def (tree var)
789 {
790   unsigned i;
791
792   /* Don't allow duplicate entries.  */
793   for (i = 0; i < VARRAY_ACTIVE_SIZE (build_v_must_defs); i++)
794     if (var == VARRAY_TREE (build_v_must_defs, i))
795       return;
796
797   VARRAY_PUSH_TREE (build_v_must_defs, var);
798 }
799
800 /* Create an operands cache for STMT, returning it in NEW_OPS. OLD_OPS are the
801    original operands, and if ANN is non-null, appropriate stmt flags are set
802    in the stmt's annotation.  Note that some fields in old_ops may 
803    change to NULL, although none of the memory they originally pointed to 
804    will be destroyed.  It is appropriate to call free_stmt_operands() on 
805    the value returned in old_ops.
806
807    The rationale for this: Certain optimizations wish to exmaine the difference
808    between new_ops and old_ops after processing.  If a set of operands don't
809    change, new_ops will simply assume the pointer in old_ops, and the old_ops
810    pointer will be set to NULL, indicating no memory needs to be cleared.  
811    Usage might appear something like:
812
813        old_ops_copy = old_ops = stmt_ann(stmt)->operands;
814        build_ssa_operands (stmt, NULL, &old_ops, &new_ops);
815           <* compare old_ops_copy and new_ops *>
816        free_ssa_operands (old_ops);                                     */
817
818 void
819 build_ssa_operands (tree stmt, stmt_ann_t ann, stmt_operands_p old_ops, 
820                     stmt_operands_p new_ops)
821 {
822   enum tree_code code;
823   tree_ann_t saved_ann = stmt->common.ann;
824   
825   /* Replace stmt's annotation with the one passed in for the duration
826      of the operand building process.  This allows "fake" stmts to be built
827      and not be included in other data structures which can be built here.  */
828   stmt->common.ann = (tree_ann_t) ann;
829   
830   /* Initially assume that the statement has no volatile operands, nor
831      makes aliased loads or stores.  */
832   if (ann)
833     {
834       ann->has_volatile_ops = false;
835       ann->makes_aliased_stores = false;
836       ann->makes_aliased_loads = false;
837     }
838
839   start_ssa_stmt_operands ();
840
841   code = TREE_CODE (stmt);
842   switch (code)
843     {
844     case MODIFY_EXPR:
845       get_expr_operands (stmt, &TREE_OPERAND (stmt, 1), opf_none);
846       if (TREE_CODE (TREE_OPERAND (stmt, 0)) == ARRAY_REF 
847           || TREE_CODE (TREE_OPERAND (stmt, 0)) == ARRAY_RANGE_REF
848           || TREE_CODE (TREE_OPERAND (stmt, 0)) == COMPONENT_REF
849           || TREE_CODE (TREE_OPERAND (stmt, 0)) == REALPART_EXPR
850           || TREE_CODE (TREE_OPERAND (stmt, 0)) == IMAGPART_EXPR
851           /* Use a V_MAY_DEF if the RHS might throw, as the LHS won't be
852              modified in that case.  FIXME we should represent somehow
853              that it is killed on the fallthrough path.  */
854           || tree_could_throw_p (TREE_OPERAND (stmt, 1)))
855         get_expr_operands (stmt, &TREE_OPERAND (stmt, 0), opf_is_def);
856       else
857         get_expr_operands (stmt, &TREE_OPERAND (stmt, 0), 
858                            opf_is_def | opf_kill_def);
859       break;
860
861     case COND_EXPR:
862       get_expr_operands (stmt, &COND_EXPR_COND (stmt), opf_none);
863       break;
864
865     case SWITCH_EXPR:
866       get_expr_operands (stmt, &SWITCH_COND (stmt), opf_none);
867       break;
868
869     case ASM_EXPR:
870       get_asm_expr_operands (stmt);
871       break;
872
873     case RETURN_EXPR:
874       get_expr_operands (stmt, &TREE_OPERAND (stmt, 0), opf_none);
875       break;
876
877     case GOTO_EXPR:
878       get_expr_operands (stmt, &GOTO_DESTINATION (stmt), opf_none);
879       break;
880
881     case LABEL_EXPR:
882       get_expr_operands (stmt, &LABEL_EXPR_LABEL (stmt), opf_none);
883       break;
884
885       /* These nodes contain no variable references.  */
886     case BIND_EXPR:
887     case CASE_LABEL_EXPR:
888     case TRY_CATCH_EXPR:
889     case TRY_FINALLY_EXPR:
890     case EH_FILTER_EXPR:
891     case CATCH_EXPR:
892     case RESX_EXPR:
893       break;
894
895     default:
896       /* Notice that if get_expr_operands tries to use &STMT as the operand
897          pointer (which may only happen for USE operands), we will abort in
898          append_use.  This default will handle statements like empty
899          statements, or CALL_EXPRs that may appear on the RHS of a statement
900          or as statements themselves.  */
901       get_expr_operands (stmt, &stmt, opf_none);
902       break;
903     }
904
905   finalize_ssa_stmt_operands (stmt, old_ops, new_ops);
906   stmt->common.ann = saved_ann;
907 }
908
909
910 /* Free any operands vectors in OPS.  */
911
912 static void 
913 free_ssa_operands (stmt_operands_p ops)
914 {
915   if (ops->def_ops)
916     free_defs (&(ops->def_ops));
917   if (ops->use_ops)
918     free_uses (&(ops->use_ops));
919   if (ops->vuse_ops)
920     free_vuses (&(ops->vuse_ops));
921   if (ops->v_may_def_ops)
922     free_v_may_defs (&(ops->v_may_def_ops));
923   if (ops->v_must_def_ops)
924     free_v_must_defs (&(ops->v_must_def_ops));
925 }
926
927
928 /* Get the operands of statement STMT.  Note that repeated calls to
929    get_stmt_operands for the same statement will do nothing until the
930    statement is marked modified by a call to modify_stmt().  */
931
932 void
933 get_stmt_operands (tree stmt)
934 {
935   stmt_ann_t ann;
936   stmt_operands_t old_operands;
937
938 #if defined ENABLE_CHECKING
939   /* The optimizers cannot handle statements that are nothing but a
940      _DECL.  This indicates a bug in the gimplifier.  */
941   if (SSA_VAR_P (stmt))
942     abort ();
943 #endif
944
945   /* Ignore error statements.  */
946   if (TREE_CODE (stmt) == ERROR_MARK)
947     return;
948
949   ann = get_stmt_ann (stmt);
950
951   /* If the statement has not been modified, the operands are still valid.  */
952   if (!ann->modified)
953     return;
954
955   timevar_push (TV_TREE_OPS);
956
957   old_operands = ann->operands;
958   memset (&(ann->operands), 0, sizeof (stmt_operands_t));
959
960   build_ssa_operands (stmt, ann, &old_operands, &(ann->operands));
961   free_ssa_operands (&old_operands);
962
963   /* Clear the modified bit for STMT.  Subsequent calls to
964      get_stmt_operands for this statement will do nothing until the
965      statement is marked modified by a call to modify_stmt().  */
966   ann->modified = 0;
967
968   timevar_pop (TV_TREE_OPS);
969 }
970
971
972 /* Recursively scan the expression pointed by EXPR_P in statement referred to
973    by INFO.  FLAGS is one of the OPF_* constants modifying how to interpret the
974    operands found.  */
975
976 static void
977 get_expr_operands (tree stmt, tree *expr_p, int flags)
978 {
979   enum tree_code code;
980   char class;
981   tree expr = *expr_p;
982
983   if (expr == NULL || expr == error_mark_node)
984     return;
985
986   code = TREE_CODE (expr);
987   class = TREE_CODE_CLASS (code);
988
989   switch (code)
990     {
991     case ADDR_EXPR:
992       /* We could have the address of a component, array member,
993          etc which has interesting variable references.  */
994       /* Taking the address of a variable does not represent a
995          reference to it, but the fact that the stmt takes its address will be
996          of interest to some passes (e.g. alias resolution).  */
997       add_stmt_operand (expr_p, stmt, 0);
998
999       /* If the address is invariant, there may be no interesting variable
1000          references inside.  */
1001       if (is_gimple_min_invariant (expr))
1002         return;
1003
1004       /* There should be no VUSEs created, since the referenced objects are
1005          not really accessed.  The only operands that we should find here
1006          are ARRAY_REF indices which will always be real operands (GIMPLE
1007          does not allow non-registers as array indices).  */
1008       flags |= opf_no_vops;
1009
1010       get_expr_operands (stmt, &TREE_OPERAND (expr, 0), flags);
1011       return;
1012
1013     case SSA_NAME:
1014     case VAR_DECL:
1015     case PARM_DECL:
1016     case RESULT_DECL:
1017       /* If we found a variable, add it to DEFS or USES depending
1018          on the operand flags.  */
1019       add_stmt_operand (expr_p, stmt, flags);
1020       return;
1021
1022     case INDIRECT_REF:
1023       get_indirect_ref_operands (stmt, expr, flags);
1024       return;
1025
1026     case ARRAY_REF:
1027     case ARRAY_RANGE_REF:
1028       /* Treat array references as references to the virtual variable
1029          representing the array.  The virtual variable for an ARRAY_REF
1030          is the VAR_DECL for the array.  */
1031
1032       /* Add the virtual variable for the ARRAY_REF to VDEFS or VUSES
1033          according to the value of IS_DEF.  Recurse if the LHS of the
1034          ARRAY_REF node is not a regular variable.  */
1035       if (SSA_VAR_P (TREE_OPERAND (expr, 0)))
1036         add_stmt_operand (expr_p, stmt, flags);
1037       else
1038         get_expr_operands (stmt, &TREE_OPERAND (expr, 0), flags);
1039
1040       get_expr_operands (stmt, &TREE_OPERAND (expr, 1), opf_none);
1041       get_expr_operands (stmt, &TREE_OPERAND (expr, 2), opf_none);
1042       get_expr_operands (stmt, &TREE_OPERAND (expr, 3), opf_none);
1043       return;
1044
1045     case COMPONENT_REF:
1046     case REALPART_EXPR:
1047     case IMAGPART_EXPR:
1048       /* Similarly to arrays, references to compound variables (complex
1049          types and structures/unions) are globbed.
1050
1051          FIXME: This means that
1052
1053                         a.x = 6;
1054                         a.y = 7;
1055                         foo (a.x, a.y);
1056
1057          will not be constant propagated because the two partial
1058          definitions to 'a' will kill each other.  Note that SRA may be
1059          able to fix this problem if 'a' can be scalarized.  */
1060
1061       /* If the LHS of the compound reference is not a regular variable,
1062          recurse to keep looking for more operands in the subexpression.  */
1063       if (SSA_VAR_P (TREE_OPERAND (expr, 0)))
1064         add_stmt_operand (expr_p, stmt, flags);
1065       else
1066         get_expr_operands (stmt, &TREE_OPERAND (expr, 0), flags);
1067
1068       if (code == COMPONENT_REF)
1069         get_expr_operands (stmt, &TREE_OPERAND (expr, 2), opf_none);
1070       return;
1071
1072     case WITH_SIZE_EXPR:
1073       /* WITH_SIZE_EXPR is a pass-through reference to its first argument,
1074          and an rvalue reference to its second argument.  */
1075       get_expr_operands (stmt, &TREE_OPERAND (expr, 1), opf_none);
1076       get_expr_operands (stmt, &TREE_OPERAND (expr, 0), flags);
1077       return;
1078
1079     case CALL_EXPR:
1080       get_call_expr_operands (stmt, expr);
1081       return;
1082
1083     case COND_EXPR:
1084       get_expr_operands (stmt, &COND_EXPR_COND (expr), opf_none);
1085       get_expr_operands (stmt, &TREE_OPERAND (expr, 1), opf_none);
1086       get_expr_operands (stmt, &TREE_OPERAND (expr, 2), opf_none);
1087       return;
1088
1089     case MODIFY_EXPR:
1090       {
1091         int subflags;
1092         tree op;
1093
1094         get_expr_operands (stmt, &TREE_OPERAND (expr, 1), opf_none);
1095
1096         op = TREE_OPERAND (expr, 0);
1097         if (TREE_CODE (op) == WITH_SIZE_EXPR)
1098           op = TREE_OPERAND (expr, 0);
1099         if (TREE_CODE (op) == ARRAY_REF
1100             || TREE_CODE (op) == ARRAY_RANGE_REF
1101             || TREE_CODE (op) == COMPONENT_REF
1102             || TREE_CODE (op) == REALPART_EXPR
1103             || TREE_CODE (op) == IMAGPART_EXPR)
1104           subflags = opf_is_def;
1105         else
1106           subflags = opf_is_def | opf_kill_def;
1107
1108         get_expr_operands (stmt, &TREE_OPERAND (expr, 0), subflags);
1109         return;
1110       }
1111
1112     case CONSTRUCTOR:
1113       {
1114         /* General aggregate CONSTRUCTORs have been decomposed, but they
1115            are still in use as the COMPLEX_EXPR equivalent for vectors.  */
1116
1117         tree t;
1118         for (t = TREE_OPERAND (expr, 0); t ; t = TREE_CHAIN (t))
1119           get_expr_operands (stmt, &TREE_VALUE (t), opf_none);
1120
1121         return;
1122       }
1123
1124     case TRUTH_NOT_EXPR:
1125     case BIT_FIELD_REF:
1126     case VIEW_CONVERT_EXPR:
1127     do_unary:
1128       get_expr_operands (stmt, &TREE_OPERAND (expr, 0), flags);
1129       return;
1130
1131     case TRUTH_AND_EXPR:
1132     case TRUTH_OR_EXPR:
1133     case TRUTH_XOR_EXPR:
1134     case COMPOUND_EXPR:
1135     case OBJ_TYPE_REF:
1136     do_binary:
1137       {
1138         tree op0 = TREE_OPERAND (expr, 0);
1139         tree op1 = TREE_OPERAND (expr, 1);
1140
1141         /* If it would be profitable to swap the operands, then do so to
1142            canonicalize the statement, enabling better optimization.
1143
1144            By placing canonicalization of such expressions here we
1145            transparently keep statements in canonical form, even
1146            when the statement is modified.  */
1147         if (tree_swap_operands_p (op0, op1, false))
1148           {
1149             /* For relationals we need to swap the operands
1150                and change the code.  */
1151             if (code == LT_EXPR
1152                 || code == GT_EXPR
1153                 || code == LE_EXPR
1154                 || code == GE_EXPR)
1155               {
1156                 TREE_SET_CODE (expr, swap_tree_comparison (code));
1157                 TREE_OPERAND (expr, 0) = op1;
1158                 TREE_OPERAND (expr, 1) = op0;
1159               }
1160           
1161             /* For a commutative operator we can just swap the operands.  */
1162             else if (commutative_tree_code (code))
1163               {
1164                 TREE_OPERAND (expr, 0) = op1;
1165                 TREE_OPERAND (expr, 1) = op0;
1166               }
1167           }
1168
1169         get_expr_operands (stmt, &TREE_OPERAND (expr, 0), flags);
1170         get_expr_operands (stmt, &TREE_OPERAND (expr, 1), flags);
1171         return;
1172       }
1173
1174     case BLOCK:
1175     case FUNCTION_DECL:
1176     case EXC_PTR_EXPR:
1177     case FILTER_EXPR:
1178     case LABEL_DECL:
1179       /* Expressions that make no memory references.  */
1180       return;
1181
1182     default:
1183       if (class == '1')
1184         goto do_unary;
1185       if (class == '2' || class == '<')
1186         goto do_binary;
1187       if (class == 'c' || class == 't')
1188         return;
1189     }
1190
1191   /* If we get here, something has gone wrong.  */
1192   fprintf (stderr, "unhandled expression in get_expr_operands():\n");
1193   debug_tree (expr);
1194   fputs ("\n", stderr);
1195   abort ();
1196 }
1197
1198
1199 /* Scan operands in the ASM_EXPR stmt refered to in INFO.  */
1200
1201 static void
1202 get_asm_expr_operands (tree stmt)
1203 {
1204   stmt_ann_t s_ann = stmt_ann (stmt);
1205   int noutputs = list_length (ASM_OUTPUTS (stmt));
1206   const char **oconstraints
1207     = (const char **) alloca ((noutputs) * sizeof (const char *));
1208   int i;
1209   tree link;
1210   const char *constraint;
1211   bool allows_mem, allows_reg, is_inout;
1212
1213   for (i=0, link = ASM_OUTPUTS (stmt); link; ++i, link = TREE_CHAIN (link))
1214     {
1215       oconstraints[i] = constraint
1216         = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (link)));
1217       parse_output_constraint (&constraint, i, 0, 0,
1218           &allows_mem, &allows_reg, &is_inout);
1219
1220 #if defined ENABLE_CHECKING
1221       /* This should have been split in gimplify_asm_expr.  */
1222       if (allows_reg && is_inout)
1223         abort ();
1224 #endif
1225
1226       /* Memory operands are addressable.  Note that STMT needs the
1227          address of this operand.  */
1228       if (!allows_reg && allows_mem)
1229         {
1230           tree t = get_base_address (TREE_VALUE (link));
1231           if (t && DECL_P (t))
1232             note_addressable (t, s_ann);
1233         }
1234
1235       get_expr_operands (stmt, &TREE_VALUE (link), opf_is_def);
1236     }
1237
1238   for (link = ASM_INPUTS (stmt); link; link = TREE_CHAIN (link))
1239     {
1240       constraint
1241         = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (link)));
1242       parse_input_constraint (&constraint, 0, 0, noutputs, 0,
1243           oconstraints, &allows_mem, &allows_reg);
1244
1245       /* Memory operands are addressable.  Note that STMT needs the
1246          address of this operand.  */
1247       if (!allows_reg && allows_mem)
1248         {
1249           tree t = get_base_address (TREE_VALUE (link));
1250           if (t && DECL_P (t))
1251             note_addressable (t, s_ann);
1252         }
1253
1254       get_expr_operands (stmt, &TREE_VALUE (link), 0);
1255     }
1256
1257
1258   /* Clobber memory for asm ("" : : : "memory");  */
1259   for (link = ASM_CLOBBERS (stmt); link; link = TREE_CHAIN (link))
1260     if (strcmp (TREE_STRING_POINTER (TREE_VALUE (link)), "memory") == 0)
1261       {
1262         size_t i;
1263
1264         /* Clobber all call-clobbered variables (or .GLOBAL_VAR if we
1265            decided to group them).  */
1266         if (global_var)
1267           add_stmt_operand (&global_var, stmt, opf_is_def);
1268         else
1269           EXECUTE_IF_SET_IN_BITMAP (call_clobbered_vars, 0, i,
1270               {
1271                 tree var = referenced_var (i);
1272                 add_stmt_operand (&var, stmt, opf_is_def);
1273               });
1274
1275         /* Now clobber all addressables.  */
1276         EXECUTE_IF_SET_IN_BITMAP (addressable_vars, 0, i,
1277             {
1278               tree var = referenced_var (i);
1279               add_stmt_operand (&var, stmt, opf_is_def);
1280             });
1281
1282         break;
1283       }
1284 }
1285
1286 /* A subroutine of get_expr_operands to handle INDIRECT_REF.  */
1287
1288 static void
1289 get_indirect_ref_operands (tree stmt, tree expr, int flags)
1290 {
1291   tree *pptr = &TREE_OPERAND (expr, 0);
1292   tree ptr = *pptr;
1293   stmt_ann_t ann = stmt_ann (stmt);
1294
1295   /* Stores into INDIRECT_REF operands are never killing definitions.  */
1296   flags &= ~opf_kill_def;
1297
1298   if (REF_ORIGINAL (expr))
1299     {
1300       enum tree_code ocode = TREE_CODE (REF_ORIGINAL (expr));
1301
1302       /* If we originally accessed part of a structure, we do it still.  */
1303       if (ocode == ARRAY_REF
1304           || ocode == COMPONENT_REF
1305           || ocode == REALPART_EXPR
1306           || ocode == IMAGPART_EXPR)
1307         flags &= ~opf_kill_def;
1308     }
1309
1310   if (SSA_VAR_P (ptr))
1311     {
1312       struct ptr_info_def *pi = NULL;
1313
1314       /* If PTR has flow-sensitive points-to information, use it.  */
1315       if (TREE_CODE (ptr) == SSA_NAME
1316           && (pi = SSA_NAME_PTR_INFO (ptr)) != NULL
1317           && pi->name_mem_tag)
1318         {
1319           /* PTR has its own memory tag.  Use it.  */
1320           add_stmt_operand (&pi->name_mem_tag, stmt, flags);
1321         }
1322       else
1323         {
1324           /* If PTR is not an SSA_NAME or it doesn't have a name
1325              tag, use its type memory tag.  */
1326           var_ann_t ann;
1327
1328           /* If we are emitting debugging dumps, display a warning if
1329              PTR is an SSA_NAME with no flow-sensitive alias
1330              information.  That means that we may need to compute
1331              aliasing again.  */
1332           if (dump_file
1333               && TREE_CODE (ptr) == SSA_NAME
1334               && pi == NULL)
1335             {
1336               fprintf (dump_file,
1337                   "NOTE: no flow-sensitive alias info for ");
1338               print_generic_expr (dump_file, ptr, dump_flags);
1339               fprintf (dump_file, " in ");
1340               print_generic_stmt (dump_file, stmt, dump_flags);
1341             }
1342
1343           if (TREE_CODE (ptr) == SSA_NAME)
1344             ptr = SSA_NAME_VAR (ptr);
1345           ann = var_ann (ptr);
1346           if (ann->type_mem_tag)
1347             add_stmt_operand (&ann->type_mem_tag, stmt, flags);
1348         }
1349     }
1350
1351   /* If a constant is used as a pointer, we can't generate a real
1352      operand for it but we mark the statement volatile to prevent
1353      optimizations from messing things up.  */
1354   else if (TREE_CODE (ptr) == INTEGER_CST)
1355     {
1356       if (ann)
1357         ann->has_volatile_ops = true;
1358       return;
1359     }
1360
1361   /* Everything else *should* have been folded elsewhere, but users
1362      are smarter than we in finding ways to write invalid code.  We
1363      cannot just abort here.  If we were absolutely certain that we
1364      do handle all valid cases, then we could just do nothing here.
1365      That seems optimistic, so attempt to do something logical... */
1366   else if ((TREE_CODE (ptr) == PLUS_EXPR || TREE_CODE (ptr) == MINUS_EXPR)
1367            && TREE_CODE (TREE_OPERAND (ptr, 0)) == ADDR_EXPR
1368            && TREE_CODE (TREE_OPERAND (ptr, 1)) == INTEGER_CST)
1369     {
1370       /* Make sure we know the object is addressable.  */
1371       pptr = &TREE_OPERAND (ptr, 0);
1372       add_stmt_operand (pptr, stmt, 0);
1373
1374       /* Mark the object itself with a VUSE.  */
1375       pptr = &TREE_OPERAND (*pptr, 0);
1376       get_expr_operands (stmt, pptr, flags);
1377       return;
1378     }
1379
1380   /* Ok, this isn't even is_gimple_min_invariant.  Something's broke.  */
1381   else
1382     abort ();
1383
1384   /* Add a USE operand for the base pointer.  */
1385   get_expr_operands (stmt, pptr, opf_none);
1386 }
1387
1388 /* A subroutine of get_expr_operands to handle CALL_EXPR.  */
1389
1390 static void
1391 get_call_expr_operands (tree stmt, tree expr)
1392 {
1393   tree op;
1394   int call_flags = call_expr_flags (expr);
1395
1396   /* Find uses in the called function.  */
1397   get_expr_operands (stmt, &TREE_OPERAND (expr, 0), opf_none);
1398
1399   for (op = TREE_OPERAND (expr, 1); op; op = TREE_CHAIN (op))
1400     get_expr_operands (stmt, &TREE_VALUE (op), opf_none);
1401
1402   get_expr_operands (stmt, &TREE_OPERAND (expr, 2), opf_none);
1403
1404   if (bitmap_first_set_bit (call_clobbered_vars) >= 0)
1405     {
1406       /* A 'pure' or a 'const' functions never call clobber anything. 
1407          A 'noreturn' function might, but since we don't return anyway 
1408          there is no point in recording that.  */ 
1409       if (TREE_SIDE_EFFECTS (expr)
1410           && !(call_flags & (ECF_PURE | ECF_CONST | ECF_NORETURN)))
1411         add_call_clobber_ops (stmt);
1412       else if (!(call_flags & ECF_CONST))
1413         add_call_read_ops (stmt);
1414     }
1415 }
1416
1417
1418 /* Add *VAR_P to the appropriate operand array for INFO.  FLAGS is as in
1419    get_expr_operands.  If *VAR_P is a GIMPLE register, it will be added to
1420    the statement's real operands, otherwise it is added to virtual
1421    operands.  */
1422
1423 static void
1424 add_stmt_operand (tree *var_p, tree stmt, int flags)
1425 {
1426   bool is_real_op;
1427   tree var, sym;
1428   stmt_ann_t s_ann = stmt_ann (stmt);
1429   var_ann_t v_ann;
1430
1431   var = *var_p;
1432   STRIP_NOPS (var);
1433
1434   /* If the operand is an ADDR_EXPR, add its operand to the list of
1435      variables that have had their address taken in this statement.  */
1436   if (TREE_CODE (var) == ADDR_EXPR)
1437     {
1438       note_addressable (TREE_OPERAND (var, 0), s_ann);
1439       return;
1440     }
1441
1442   /* If the original variable is not a scalar, it will be added to the list
1443      of virtual operands.  In that case, use its base symbol as the virtual
1444      variable representing it.  */
1445   is_real_op = is_gimple_reg (var);
1446   if (!is_real_op && !DECL_P (var))
1447     var = get_virtual_var (var);
1448
1449   /* If VAR is not a variable that we care to optimize, do nothing.  */
1450   if (var == NULL_TREE || !SSA_VAR_P (var))
1451     return;
1452
1453   sym = (TREE_CODE (var) == SSA_NAME ? SSA_NAME_VAR (var) : var);
1454   v_ann = var_ann (sym);
1455
1456   /* Don't expose volatile variables to the optimizers.  */
1457   if (TREE_THIS_VOLATILE (sym))
1458     {
1459       if (s_ann)
1460         s_ann->has_volatile_ops = true;
1461       return;
1462     }
1463
1464   if (is_real_op)
1465     {
1466       /* The variable is a GIMPLE register.  Add it to real operands.  */
1467       if (flags & opf_is_def)
1468         append_def (var_p);
1469       else
1470         append_use (var_p);
1471     }
1472   else
1473     {
1474       varray_type aliases;
1475
1476       /* The variable is not a GIMPLE register.  Add it (or its aliases) to
1477          virtual operands, unless the caller has specifically requested
1478          not to add virtual operands (used when adding operands inside an
1479          ADDR_EXPR expression).  */
1480       if (flags & opf_no_vops)
1481         return;
1482
1483       aliases = v_ann->may_aliases;
1484
1485       if (aliases == NULL)
1486         {
1487           /* The variable is not aliased or it is an alias tag.  */
1488           if (flags & opf_is_def)
1489             {
1490               if (flags & opf_kill_def)
1491                 {
1492 #if defined ENABLE_CHECKING
1493                   /* Only regular variables may get a V_MUST_DEF
1494                      operand.  */
1495                   if (v_ann->mem_tag_kind != NOT_A_TAG)
1496                     abort ();
1497 #endif
1498                   /* V_MUST_DEF for non-aliased, non-GIMPLE register 
1499                     variable definitions.  */
1500                   append_v_must_def (var);
1501                 }
1502               else
1503                 {
1504                   /* Add a V_MAY_DEF for call-clobbered variables and
1505                      memory tags.  */
1506                   append_v_may_def (var);
1507                 }
1508             }
1509           else
1510             {
1511               append_vuse (var);
1512               if (s_ann && v_ann->is_alias_tag)
1513                 s_ann->makes_aliased_loads = 1;
1514             }
1515         }
1516       else
1517         {
1518           size_t i;
1519
1520           /* The variable is aliased.  Add its aliases to the virtual
1521              operands.  */
1522 #if defined ENABLE_CHECKING
1523           if (VARRAY_ACTIVE_SIZE (aliases) == 0)
1524             abort ();
1525 #endif
1526
1527           if (flags & opf_is_def)
1528             {
1529               /* If the variable is also an alias tag, add a virtual
1530                  operand for it, otherwise we will miss representing
1531                  references to the members of the variable's alias set.
1532                  This fixes the bug in gcc.c-torture/execute/20020503-1.c.  */
1533               if (v_ann->is_alias_tag)
1534                 append_v_may_def (var);
1535
1536               for (i = 0; i < VARRAY_ACTIVE_SIZE (aliases); i++)
1537                 append_v_may_def (VARRAY_TREE (aliases, i));
1538
1539               if (s_ann)
1540                 s_ann->makes_aliased_stores = 1;
1541             }
1542           else
1543             {
1544               /* Similarly, append a virtual uses for VAR itself, when
1545                  it is an alias tag.  */
1546               if (v_ann->is_alias_tag)
1547                 append_vuse (var);
1548
1549               for (i = 0; i < VARRAY_ACTIVE_SIZE (aliases); i++)
1550                 append_vuse (VARRAY_TREE (aliases, i));
1551
1552               if (s_ann)
1553                 s_ann->makes_aliased_loads = 1;
1554             }
1555         }
1556     }
1557 }
1558
1559
1560 /* Record that VAR had its address taken in the statement with annotations
1561    S_ANN.  */
1562
1563 static void
1564 note_addressable (tree var, stmt_ann_t s_ann)
1565 {
1566   if (!s_ann)
1567     return;
1568
1569   var = get_base_address (var);
1570   if (var && SSA_VAR_P (var))
1571     {
1572       if (s_ann->addresses_taken == NULL)
1573         s_ann->addresses_taken = BITMAP_GGC_ALLOC ();
1574       bitmap_set_bit (s_ann->addresses_taken, var_ann (var)->uid);
1575     }
1576 }
1577
1578
1579 /* Add clobbering definitions for .GLOBAL_VAR or for each of the call
1580    clobbered variables in the function.  */
1581
1582 static void
1583 add_call_clobber_ops (tree stmt)
1584 {
1585   /* Functions that are not const, pure or never return may clobber
1586      call-clobbered variables.  */
1587   if (stmt_ann (stmt))
1588     stmt_ann (stmt)->makes_clobbering_call = true;
1589
1590   /* If we had created .GLOBAL_VAR earlier, use it.  Otherwise, add 
1591      a V_MAY_DEF operand for every call clobbered variable.  See 
1592      compute_may_aliases for the heuristic used to decide whether 
1593      to create .GLOBAL_VAR or not.  */
1594   if (global_var)
1595     add_stmt_operand (&global_var, stmt, opf_is_def);
1596   else
1597     {
1598       size_t i;
1599
1600       EXECUTE_IF_SET_IN_BITMAP (call_clobbered_vars, 0, i,
1601         {
1602           tree var = referenced_var (i);
1603
1604           /* If VAR is read-only, don't add a V_MAY_DEF, just a 
1605              VUSE operand.  */
1606           if (!TREE_READONLY (var))
1607             add_stmt_operand (&var, stmt, opf_is_def);
1608           else
1609             add_stmt_operand (&var, stmt, opf_none);
1610         });
1611     }
1612 }
1613
1614
1615 /* Add VUSE operands for .GLOBAL_VAR or all call clobbered variables in the
1616    function.  */
1617
1618 static void
1619 add_call_read_ops (tree stmt)
1620 {
1621   /* Otherwise, if the function is not pure, it may reference memory.  Add
1622      a VUSE for .GLOBAL_VAR if it has been created.  Otherwise, add a VUSE
1623      for each call-clobbered variable.  See add_referenced_var for the
1624      heuristic used to decide whether to create .GLOBAL_VAR.  */
1625   if (global_var)
1626     add_stmt_operand (&global_var, stmt, opf_none);
1627   else
1628     {
1629       size_t i;
1630
1631       EXECUTE_IF_SET_IN_BITMAP (call_clobbered_vars, 0, i,
1632         {
1633           tree var = referenced_var (i);
1634           add_stmt_operand (&var, stmt, opf_none);
1635         });
1636     }
1637 }
1638
1639 /* Copies virtual operands from SRC to DST.  */
1640
1641 void
1642 copy_virtual_operands (tree dst, tree src)
1643 {
1644   unsigned i;
1645   vuse_optype vuses = STMT_VUSE_OPS (src);
1646   v_may_def_optype v_may_defs = STMT_V_MAY_DEF_OPS (src);
1647   v_must_def_optype v_must_defs = STMT_V_MUST_DEF_OPS (src);
1648   vuse_optype *vuses_new = &stmt_ann (dst)->operands.vuse_ops;
1649   v_may_def_optype *v_may_defs_new = &stmt_ann (dst)->operands.v_may_def_ops;
1650   v_must_def_optype *v_must_defs_new = &stmt_ann (dst)->operands.v_must_def_ops;
1651
1652   if (vuses)
1653     {
1654       *vuses_new = allocate_vuse_optype (NUM_VUSES (vuses));
1655       for (i = 0; i < NUM_VUSES (vuses); i++)
1656         SET_VUSE_OP (*vuses_new, i, VUSE_OP (vuses, i));
1657     }
1658
1659   if (v_may_defs)
1660     {
1661       *v_may_defs_new = allocate_v_may_def_optype (NUM_V_MAY_DEFS (v_may_defs));
1662       for (i = 0; i < NUM_V_MAY_DEFS (v_may_defs); i++)
1663         {
1664           SET_V_MAY_DEF_OP (*v_may_defs_new, i, V_MAY_DEF_OP (v_may_defs, i));
1665           SET_V_MAY_DEF_RESULT (*v_may_defs_new, i, 
1666                                 V_MAY_DEF_RESULT (v_may_defs, i));
1667         }
1668     }
1669
1670   if (v_must_defs)
1671     {
1672       *v_must_defs_new = allocate_v_must_def_optype (NUM_V_MUST_DEFS (v_must_defs));
1673       for (i = 0; i < NUM_V_MUST_DEFS (v_must_defs); i++)
1674         SET_V_MUST_DEF_OP (*v_must_defs_new, i, V_MUST_DEF_OP (v_must_defs, i));
1675     }
1676 }
1677
1678
1679 /* Specifically for use in DOM's expression analysis.  Given a store, we
1680    create an artificial stmt which looks like a load from the store, this can
1681    be used to eliminate redundant loads.  OLD_OPS are the operands from the 
1682    store stmt, and NEW_STMT is the new load which represents a load of the
1683    values stored.  */
1684
1685 void
1686 create_ssa_artficial_load_stmt (stmt_operands_p old_ops, tree new_stmt)
1687 {
1688   stmt_ann_t ann;
1689   tree op;
1690   stmt_operands_t tmp;
1691   unsigned j;
1692
1693   memset (&tmp, 0, sizeof (stmt_operands_t));
1694   ann = get_stmt_ann (new_stmt);
1695
1696   /* Free operands just in case is was an existing stmt.  */
1697   free_ssa_operands (&(ann->operands));
1698
1699   build_ssa_operands (new_stmt, NULL, &tmp, &(ann->operands));
1700   free_vuses (&(ann->operands.vuse_ops));
1701   free_v_may_defs (&(ann->operands.v_may_def_ops));
1702   free_v_must_defs (&(ann->operands.v_must_def_ops));
1703
1704   /* For each VDEF on the original statement, we want to create a
1705      VUSE of the V_MAY_DEF result or V_MUST_DEF op on the new 
1706      statement.  */
1707   for (j = 0; j < NUM_V_MAY_DEFS (old_ops->v_may_def_ops); j++)
1708     {
1709       op = V_MAY_DEF_RESULT (old_ops->v_may_def_ops, j);
1710       append_vuse (op);
1711     }
1712     
1713   for (j = 0; j < NUM_V_MUST_DEFS (old_ops->v_must_def_ops); j++)
1714     {
1715       op = V_MUST_DEF_OP (old_ops->v_must_def_ops, j);
1716       append_vuse (op);
1717     }
1718
1719   /* Now set the vuses for this new stmt.  */
1720   ann->operands.vuse_ops = finalize_ssa_vuses (&(tmp.vuse_ops));
1721 }
1722
1723 #include "gt-tree-ssa-operands.h"