1 /* SSA operands management for trees.
2    Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
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 "tree-pretty-print.h"
29 #include "gimple-pretty-print.h"
30 #include "tree-flow.h"
31 #include "tree-inline.h"
32 #include "tree-pass.h"
33 #include "ggc.h"
34 #include "timevar.h"
35 #include "langhooks.h"
36 #include "diagnostic-core.h"
37 
38 
39 /* This file contains the code required to manage the operands cache of the
40    SSA optimizer.  For every stmt, we maintain an operand cache in the stmt
41    annotation.  This cache contains operands that will be of interest to
42    optimizers and other passes wishing to manipulate the IL.
43 
44    The operand type are broken up into REAL and VIRTUAL operands.  The real
45    operands are represented as pointers into the stmt's operand tree.  Thus
46    any manipulation of the real operands will be reflected in the actual tree.
47    Virtual operands are represented solely in the cache, although the base
48    variable for the SSA_NAME may, or may not occur in the stmt's tree.
49    Manipulation of the virtual operands will not be reflected in the stmt tree.
50 
51    The routines in this file are concerned with creating this operand cache
52    from a stmt tree.
53 
54    The operand tree is the parsed by the various get_* routines which look
55    through the stmt tree for the occurrence of operands which may be of
56    interest, and calls are made to the append_* routines whenever one is
57    found.  There are 4 of these routines, each representing one of the
58    4 types of operands. Defs, Uses, Virtual Uses, and Virtual May 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 4 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 it's 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    i.e., if a stmt had a VUSE of 'a_5', and 'a' occurs in the new
76    operand vector for VUSE, then the new vector will also be modified
77    such that it contains 'a_5' rather than 'a'.  */
78 
79 /* Structure storing statistics on how many call clobbers we have, and
80    how many where avoided.  */
81 
82 static struct
83 {
84   /* Number of call-clobbered ops we attempt to add to calls in
85      add_call_clobbered_mem_symbols.  */
86   unsigned int clobbered_vars;
87 
88   /* Number of write-clobbers (VDEFs) avoided by using
89      not_written information.  */
90   unsigned int static_write_clobbers_avoided;
91 
92   /* Number of reads (VUSEs) avoided by using not_read information.  */
93   unsigned int static_read_clobbers_avoided;
94 
95   /* Number of write-clobbers avoided because the variable can't escape to
96      this call.  */
97   unsigned int unescapable_clobbers_avoided;
98 
99   /* Number of read-only uses we attempt to add to calls in
100      add_call_read_mem_symbols.  */
101   unsigned int readonly_clobbers;
102 
103   /* Number of read-only uses we avoid using not_read information.  */
104   unsigned int static_readonly_clobbers_avoided;
105 } clobber_stats;
106 
107 
108 /* Flags to describe operand properties in helpers.  */
109 
110 /* By default, operands are loaded.  */
111 #define opf_use		0
112 
113 /* Operand is the target of an assignment expression or a
114    call-clobbered variable.  */
115 #define opf_def 	(1 << 0)
116 
117 /* No virtual operands should be created in the expression.  This is used
118    when traversing ADDR_EXPR nodes which have different semantics than
119    other expressions.  Inside an ADDR_EXPR node, the only operands that we
120    need to consider are indices into arrays.  For instance, &a.b[i] should
121    generate a USE of 'i' but it should not generate a VUSE for 'a' nor a
122    VUSE for 'b'.  */
123 #define opf_no_vops 	(1 << 1)
124 
125 /* Operand is an implicit reference.  This is used to distinguish
126    explicit assignments in the form of MODIFY_EXPR from
127    clobbering sites like function calls or ASM_EXPRs.  */
128 #define opf_implicit	(1 << 2)
129 
130 /* Operand is in a place where address-taken does not imply addressable.  */
131 #define opf_non_addressable (1 << 3)
132 
133 /* Operand is in a place where opf_non_addressable does not apply.  */
134 #define opf_not_non_addressable (1 << 4)
135 
136 /* Array for building all the def operands.  */
137 static VEC(tree,heap) *build_defs;
138 
139 /* Array for building all the use operands.  */
140 static VEC(tree,heap) *build_uses;
141 
142 /* The built VDEF operand.  */
143 static tree build_vdef;
144 
145 /* The built VUSE operand.  */
146 static tree build_vuse;
147 
148 /* Bitmap obstack for our datastructures that needs to survive across
149    compilations of multiple functions.  */
150 static bitmap_obstack operands_bitmap_obstack;
151 
152 static void get_expr_operands (gimple, tree *, int);
153 
154 /* Number of functions with initialized ssa_operands.  */
155 static int n_initialized = 0;
156 
157 /* Return the DECL_UID of the base variable of T.  */
158 
159 static inline unsigned
160 get_name_decl (const_tree t)
161 {
162   if (TREE_CODE (t) != SSA_NAME)
163     return DECL_UID (t);
164   else
165     return DECL_UID (SSA_NAME_VAR (t));
166 }
167 
168 
169 /*  Return true if the SSA operands cache is active.  */
170 
171 bool
172 ssa_operands_active (void)
173 {
174   /* This function may be invoked from contexts where CFUN is NULL
175      (IPA passes), return false for now.  FIXME: operands may be
176      active in each individual function, maybe this function should
177      take CFUN as a parameter.  */
178   if (cfun == NULL)
179     return false;
180 
181   return cfun->gimple_df && gimple_ssa_operands (cfun)->ops_active;
182 }
183 
184 
185 /* Create the VOP variable, an artificial global variable to act as a
186    representative of all of the virtual operands FUD chain.  */
187 
188 static void
189 create_vop_var (void)
190 {
191   tree global_var;
192 
193   gcc_assert (cfun->gimple_df->vop == NULL_TREE);
194 
195   global_var = build_decl (BUILTINS_LOCATION, VAR_DECL,
196 			   get_identifier (".MEM"),
197 			   void_type_node);
198   DECL_ARTIFICIAL (global_var) = 1;
199   TREE_READONLY (global_var) = 0;
200   DECL_EXTERNAL (global_var) = 1;
201   TREE_STATIC (global_var) = 1;
202   TREE_USED (global_var) = 1;
203   DECL_CONTEXT (global_var) = NULL_TREE;
204   TREE_THIS_VOLATILE (global_var) = 0;
205   TREE_ADDRESSABLE (global_var) = 0;
206 
207   create_var_ann (global_var);
208   add_referenced_var (global_var);
209   cfun->gimple_df->vop = global_var;
210 }
211 
212 /* These are the sizes of the operand memory buffer in bytes which gets
213    allocated each time more operands space is required.  The final value is
214    the amount that is allocated every time after that.
215    In 1k we can fit 25 use operands (or 63 def operands) on a host with
216    8 byte pointers, that would be 10 statements each with 1 def and 2
217    uses.  */
218 
219 #define OP_SIZE_INIT	0
220 #define OP_SIZE_1	(1024 - sizeof (void *))
221 #define OP_SIZE_2	(1024 * 4 - sizeof (void *))
222 #define OP_SIZE_3	(1024 * 16 - sizeof (void *))
223 
224 /* Initialize the operand cache routines.  */
225 
226 void
227 init_ssa_operands (void)
228 {
229   if (!n_initialized++)
230     {
231       build_defs = VEC_alloc (tree, heap, 5);
232       build_uses = VEC_alloc (tree, heap, 10);
233       build_vuse = NULL_TREE;
234       build_vdef = NULL_TREE;
235       bitmap_obstack_initialize (&operands_bitmap_obstack);
236     }
237 
238   gcc_assert (gimple_ssa_operands (cfun)->operand_memory == NULL);
239   gimple_ssa_operands (cfun)->operand_memory_index
240      = gimple_ssa_operands (cfun)->ssa_operand_mem_size;
241   gimple_ssa_operands (cfun)->ops_active = true;
242   memset (&clobber_stats, 0, sizeof (clobber_stats));
243   gimple_ssa_operands (cfun)->ssa_operand_mem_size = OP_SIZE_INIT;
244   create_vop_var ();
245 }
246 
247 
248 /* Dispose of anything required by the operand routines.  */
249 
250 void
251 fini_ssa_operands (void)
252 {
253   struct ssa_operand_memory_d *ptr;
254 
255   if (!--n_initialized)
256     {
257       VEC_free (tree, heap, build_defs);
258       VEC_free (tree, heap, build_uses);
259       build_vdef = NULL_TREE;
260       build_vuse = NULL_TREE;
261     }
262 
263   gimple_ssa_operands (cfun)->free_defs = NULL;
264   gimple_ssa_operands (cfun)->free_uses = NULL;
265 
266   while ((ptr = gimple_ssa_operands (cfun)->operand_memory) != NULL)
267     {
268       gimple_ssa_operands (cfun)->operand_memory
269 	= gimple_ssa_operands (cfun)->operand_memory->next;
270       ggc_free (ptr);
271     }
272 
273   gimple_ssa_operands (cfun)->ops_active = false;
274 
275   if (!n_initialized)
276     bitmap_obstack_release (&operands_bitmap_obstack);
277 
278   cfun->gimple_df->vop = NULL_TREE;
279 
280   if (dump_file && (dump_flags & TDF_STATS))
281     {
282       fprintf (dump_file, "Original clobbered vars:           %d\n",
283 	       clobber_stats.clobbered_vars);
284       fprintf (dump_file, "Static write clobbers avoided:     %d\n",
285 	       clobber_stats.static_write_clobbers_avoided);
286       fprintf (dump_file, "Static read clobbers avoided:      %d\n",
287 	       clobber_stats.static_read_clobbers_avoided);
288       fprintf (dump_file, "Unescapable clobbers avoided:      %d\n",
289 	       clobber_stats.unescapable_clobbers_avoided);
290       fprintf (dump_file, "Original read-only clobbers:       %d\n",
291 	       clobber_stats.readonly_clobbers);
292       fprintf (dump_file, "Static read-only clobbers avoided: %d\n",
293 	       clobber_stats.static_readonly_clobbers_avoided);
294     }
295 }
296 
297 
298 /* Return memory for an operand of size SIZE.  */
299 
300 static inline void *
301 ssa_operand_alloc (unsigned size)
302 {
303   char *ptr;
304 
305   gcc_assert (size == sizeof (struct use_optype_d)
306 	      || size == sizeof (struct def_optype_d));
307 
308   if (gimple_ssa_operands (cfun)->operand_memory_index + size
309       >= gimple_ssa_operands (cfun)->ssa_operand_mem_size)
310     {
311       struct ssa_operand_memory_d *ptr;
312 
313       switch (gimple_ssa_operands (cfun)->ssa_operand_mem_size)
314 	{
315 	case OP_SIZE_INIT:
316 	  gimple_ssa_operands (cfun)->ssa_operand_mem_size = OP_SIZE_1;
317 	  break;
318 	case OP_SIZE_1:
319 	  gimple_ssa_operands (cfun)->ssa_operand_mem_size = OP_SIZE_2;
320 	  break;
321 	case OP_SIZE_2:
322 	case OP_SIZE_3:
323 	  gimple_ssa_operands (cfun)->ssa_operand_mem_size = OP_SIZE_3;
324 	  break;
325 	default:
326 	  gcc_unreachable ();
327 	}
328 
329 
330       ptr = ggc_alloc_ssa_operand_memory_d (sizeof (void *)
331                         + gimple_ssa_operands (cfun)->ssa_operand_mem_size);
332 
333       ptr->next = gimple_ssa_operands (cfun)->operand_memory;
334       gimple_ssa_operands (cfun)->operand_memory = ptr;
335       gimple_ssa_operands (cfun)->operand_memory_index = 0;
336     }
337 
338   ptr = &(gimple_ssa_operands (cfun)->operand_memory
339 	  ->mem[gimple_ssa_operands (cfun)->operand_memory_index]);
340   gimple_ssa_operands (cfun)->operand_memory_index += size;
341   return ptr;
342 }
343 
344 
345 /* Allocate a DEF operand.  */
346 
347 static inline struct def_optype_d *
348 alloc_def (void)
349 {
350   struct def_optype_d *ret;
351   if (gimple_ssa_operands (cfun)->free_defs)
352     {
353       ret = gimple_ssa_operands (cfun)->free_defs;
354       gimple_ssa_operands (cfun)->free_defs
355 	= gimple_ssa_operands (cfun)->free_defs->next;
356     }
357   else
358     ret = (struct def_optype_d *)
359 	  ssa_operand_alloc (sizeof (struct def_optype_d));
360   return ret;
361 }
362 
363 
364 /* Allocate a USE operand.  */
365 
366 static inline struct use_optype_d *
367 alloc_use (void)
368 {
369   struct use_optype_d *ret;
370   if (gimple_ssa_operands (cfun)->free_uses)
371     {
372       ret = gimple_ssa_operands (cfun)->free_uses;
373       gimple_ssa_operands (cfun)->free_uses
374 	= gimple_ssa_operands (cfun)->free_uses->next;
375     }
376   else
377     ret = (struct use_optype_d *)
378           ssa_operand_alloc (sizeof (struct use_optype_d));
379   return ret;
380 }
381 
382 
383 /* Adds OP to the list of defs after LAST.  */
384 
385 static inline def_optype_p
386 add_def_op (tree *op, def_optype_p last)
387 {
388   def_optype_p new_def;
389 
390   new_def = alloc_def ();
391   DEF_OP_PTR (new_def) = op;
392   last->next = new_def;
393   new_def->next = NULL;
394   return new_def;
395 }
396 
397 
398 /* Adds OP to the list of uses of statement STMT after LAST.  */
399 
400 static inline use_optype_p
401 add_use_op (gimple stmt, tree *op, use_optype_p last)
402 {
403   use_optype_p new_use;
404 
405   new_use = alloc_use ();
406   USE_OP_PTR (new_use)->use = op;
407   link_imm_use_stmt (USE_OP_PTR (new_use), *op, stmt);
408   last->next = new_use;
409   new_use->next = NULL;
410   return new_use;
411 }
412 
413 
414 
415 /* Takes elements from build_defs and turns them into def operands of STMT.
416    TODO -- Make build_defs VEC of tree *.  */
417 
418 static inline void
419 finalize_ssa_defs (gimple stmt)
420 {
421   unsigned new_i;
422   struct def_optype_d new_list;
423   def_optype_p old_ops, last;
424   unsigned int num = VEC_length (tree, build_defs);
425 
426   /* There should only be a single real definition per assignment.  */
427   gcc_assert ((stmt && gimple_code (stmt) != GIMPLE_ASSIGN) || num <= 1);
428 
429   /* Pre-pend the vdef we may have built.  */
430   if (build_vdef != NULL_TREE)
431     {
432       tree oldvdef = gimple_vdef (stmt);
433       if (oldvdef
434 	  && TREE_CODE (oldvdef) == SSA_NAME)
435 	oldvdef = SSA_NAME_VAR (oldvdef);
436       if (oldvdef != build_vdef)
437 	gimple_set_vdef (stmt, build_vdef);
438       VEC_safe_insert (tree, heap, build_defs, 0, (tree)gimple_vdef_ptr (stmt));
439       ++num;
440     }
441 
442   new_list.next = NULL;
443   last = &new_list;
444 
445   old_ops = gimple_def_ops (stmt);
446 
447   new_i = 0;
448 
449   /* Clear and unlink a no longer necessary VDEF.  */
450   if (build_vdef == NULL_TREE
451       && gimple_vdef (stmt) != NULL_TREE)
452     {
453       if (TREE_CODE (gimple_vdef (stmt)) == SSA_NAME)
454 	{
455 	  unlink_stmt_vdef (stmt);
456 	  release_ssa_name (gimple_vdef (stmt));
457 	}
458       gimple_set_vdef (stmt, NULL_TREE);
459     }
460 
461   /* If we have a non-SSA_NAME VDEF, mark it for renaming.  */
462   if (gimple_vdef (stmt)
463       && TREE_CODE (gimple_vdef (stmt)) != SSA_NAME)
464     mark_sym_for_renaming (gimple_vdef (stmt));
465 
466   /* Check for the common case of 1 def that hasn't changed.  */
467   if (old_ops && old_ops->next == NULL && num == 1
468       && (tree *) VEC_index (tree, build_defs, 0) == DEF_OP_PTR (old_ops))
469     return;
470 
471   /* If there is anything in the old list, free it.  */
472   if (old_ops)
473     {
474       old_ops->next = gimple_ssa_operands (cfun)->free_defs;
475       gimple_ssa_operands (cfun)->free_defs = old_ops;
476     }
477 
478   /* If there is anything remaining in the build_defs list, simply emit it.  */
479   for ( ; new_i < num; new_i++)
480     last = add_def_op ((tree *) VEC_index (tree, build_defs, new_i), last);
481 
482   /* Now set the stmt's operands.  */
483   gimple_set_def_ops (stmt, new_list.next);
484 }
485 
486 
487 /* Takes elements from build_uses and turns them into use operands of STMT.
488    TODO -- Make build_uses VEC of tree *.  */
489 
490 static inline void
491 finalize_ssa_uses (gimple stmt)
492 {
493   unsigned new_i;
494   struct use_optype_d new_list;
495   use_optype_p old_ops, ptr, last;
496 
497   /* Pre-pend the VUSE we may have built.  */
498   if (build_vuse != NULL_TREE)
499     {
500       tree oldvuse = gimple_vuse (stmt);
501       if (oldvuse
502 	  && TREE_CODE (oldvuse) == SSA_NAME)
503 	oldvuse = SSA_NAME_VAR (oldvuse);
504       if (oldvuse != (build_vuse != NULL_TREE
505 		      ? build_vuse : build_vdef))
506 	gimple_set_vuse (stmt, NULL_TREE);
507       VEC_safe_insert (tree, heap, build_uses, 0, (tree)gimple_vuse_ptr (stmt));
508     }
509 
510   new_list.next = NULL;
511   last = &new_list;
512 
513   old_ops = gimple_use_ops (stmt);
514 
515   /* Clear a no longer necessary VUSE.  */
516   if (build_vuse == NULL_TREE
517       && gimple_vuse (stmt) != NULL_TREE)
518     gimple_set_vuse (stmt, NULL_TREE);
519 
520   /* If there is anything in the old list, free it.  */
521   if (old_ops)
522     {
523       for (ptr = old_ops; ptr; ptr = ptr->next)
524 	delink_imm_use (USE_OP_PTR (ptr));
525       old_ops->next = gimple_ssa_operands (cfun)->free_uses;
526       gimple_ssa_operands (cfun)->free_uses = old_ops;
527     }
528 
529   /* If we added a VUSE, make sure to set the operand if it is not already
530      present and mark it for renaming.  */
531   if (build_vuse != NULL_TREE
532       && gimple_vuse (stmt) == NULL_TREE)
533     {
534       gimple_set_vuse (stmt, gimple_vop (cfun));
535       mark_sym_for_renaming (gimple_vop (cfun));
536     }
537 
538   /* Now create nodes for all the new nodes.  */
539   for (new_i = 0; new_i < VEC_length (tree, build_uses); new_i++)
540     last = add_use_op (stmt,
541 		       (tree *) VEC_index (tree, build_uses, new_i),
542 		       last);
543 
544   /* Now set the stmt's operands.  */
545   gimple_set_use_ops (stmt, new_list.next);
546 }
547 
548 
549 /* Clear the in_list bits and empty the build array for VDEFs and
550    VUSEs.  */
551 
552 static inline void
553 cleanup_build_arrays (void)
554 {
555   build_vdef = NULL_TREE;
556   build_vuse = NULL_TREE;
557   VEC_truncate (tree, build_defs, 0);
558   VEC_truncate (tree, build_uses, 0);
559 }
560 
561 
562 /* Finalize all the build vectors, fill the new ones into INFO.  */
563 
564 static inline void
565 finalize_ssa_stmt_operands (gimple stmt)
566 {
567   finalize_ssa_defs (stmt);
568   finalize_ssa_uses (stmt);
569   cleanup_build_arrays ();
570 }
571 
572 
573 /* Start the process of building up operands vectors in INFO.  */
574 
575 static inline void
576 start_ssa_stmt_operands (void)
577 {
578   gcc_assert (VEC_length (tree, build_defs) == 0);
579   gcc_assert (VEC_length (tree, build_uses) == 0);
580   gcc_assert (build_vuse == NULL_TREE);
581   gcc_assert (build_vdef == NULL_TREE);
582 }
583 
584 
585 /* Add DEF_P to the list of pointers to operands.  */
586 
587 static inline void
588 append_def (tree *def_p)
589 {
590   VEC_safe_push (tree, heap, build_defs, (tree) def_p);
591 }
592 
593 
594 /* Add USE_P to the list of pointers to operands.  */
595 
596 static inline void
597 append_use (tree *use_p)
598 {
599   VEC_safe_push (tree, heap, build_uses, (tree) use_p);
600 }
601 
602 
603 /* Add VAR to the set of variables that require a VDEF operator.  */
604 
605 static inline void
606 append_vdef (tree var)
607 {
608   if (!optimize)
609     return;
610 
611   gcc_assert ((build_vdef == NULL_TREE
612 	       || build_vdef == var)
613 	      && (build_vuse == NULL_TREE
614 		  || build_vuse == var));
615 
616   build_vdef = var;
617   build_vuse = var;
618 }
619 
620 
621 /* Add VAR to the set of variables that require a VUSE operator.  */
622 
623 static inline void
624 append_vuse (tree var)
625 {
626   if (!optimize)
627     return;
628 
629   gcc_assert (build_vuse == NULL_TREE
630 	      || build_vuse == var);
631 
632   build_vuse = var;
633 }
634 
635 /* Add virtual operands for STMT.  FLAGS is as in get_expr_operands.  */
636 
637 static void
638 add_virtual_operand (gimple stmt ATTRIBUTE_UNUSED, int flags)
639 {
640   /* Add virtual operands to the stmt, unless the caller has specifically
641      requested not to do that (used when adding operands inside an
642      ADDR_EXPR expression).  */
643   if (flags & opf_no_vops)
644     return;
645 
646   gcc_assert (!is_gimple_debug (stmt));
647 
648   if (flags & opf_def)
649     append_vdef (gimple_vop (cfun));
650   else
651     append_vuse (gimple_vop (cfun));
652 }
653 
654 
655 /* Add *VAR_P to the appropriate operand array for statement STMT.
656    FLAGS is as in get_expr_operands.  If *VAR_P is a GIMPLE register,
657    it will be added to the statement's real operands, otherwise it is
658    added to virtual operands.  */
659 
660 static void
661 add_stmt_operand (tree *var_p, gimple stmt, int flags)
662 {
663   tree var, sym;
664 
665   gcc_assert (SSA_VAR_P (*var_p));
666 
667   var = *var_p;
668   sym = (TREE_CODE (var) == SSA_NAME ? SSA_NAME_VAR (var) : var);
669 
670   /* Mark statements with volatile operands.  */
671   if (!(flags & opf_no_vops)
672       && TREE_THIS_VOLATILE (sym))
673     gimple_set_has_volatile_ops (stmt, true);
674 
675   if (is_gimple_reg (sym))
676     {
677       /* The variable is a GIMPLE register.  Add it to real operands.  */
678       if (flags & opf_def)
679 	append_def (var_p);
680       else
681 	append_use (var_p);
682     }
683   else
684     add_virtual_operand (stmt, flags);
685 }
686 
687 /* Mark the base address of REF as having its address taken.
688    REF may be a single variable whose address has been taken or any
689    other valid GIMPLE memory reference (structure reference, array,
690    etc).  */
691 
692 static void
693 mark_address_taken (tree ref)
694 {
695   tree var;
696 
697   /* Note that it is *NOT OKAY* to use the target of a COMPONENT_REF
698      as the only thing we take the address of.  If VAR is a structure,
699      taking the address of a field means that the whole structure may
700      be referenced using pointer arithmetic.  See PR 21407 and the
701      ensuing mailing list discussion.  */
702   var = get_base_address (ref);
703   if (var)
704     {
705       if (DECL_P (var))
706 	TREE_ADDRESSABLE (var) = 1;
707       else if (TREE_CODE (var) == MEM_REF
708 	       && TREE_CODE (TREE_OPERAND (var, 0)) == ADDR_EXPR
709 	       && DECL_P (TREE_OPERAND (TREE_OPERAND (var, 0), 0)))
710 	TREE_ADDRESSABLE (TREE_OPERAND (TREE_OPERAND (var, 0), 0)) = 1;
711     }
712 }
713 
714 
715 /* A subroutine of get_expr_operands to handle MEM_REF.
716 
717    STMT is the statement being processed, EXPR is the MEM_REF
718       that got us here.
719 
720    FLAGS is as in get_expr_operands.
721 
722    RECURSE_ON_BASE should be set to true if we want to continue
723       calling get_expr_operands on the base pointer, and false if
724       something else will do it for us.  */
725 
726 static void
727 get_indirect_ref_operands (gimple stmt, tree expr, int flags,
728 			   bool recurse_on_base)
729 {
730   tree *pptr = &TREE_OPERAND (expr, 0);
731 
732   if (!(flags & opf_no_vops)
733       && TREE_THIS_VOLATILE (expr))
734     gimple_set_has_volatile_ops (stmt, true);
735 
736   /* Add the VOP.  */
737   add_virtual_operand (stmt, flags);
738 
739   /* If requested, add a USE operand for the base pointer.  */
740   if (recurse_on_base)
741     get_expr_operands (stmt, pptr,
742 		       opf_non_addressable | opf_use
743 		       | (flags & (opf_no_vops|opf_not_non_addressable)));
744 }
745 
746 
747 /* A subroutine of get_expr_operands to handle TARGET_MEM_REF.  */
748 
749 static void
750 get_tmr_operands (gimple stmt, tree expr, int flags)
751 {
752   if (!(flags & opf_no_vops)
753       && TREE_THIS_VOLATILE (expr))
754     gimple_set_has_volatile_ops (stmt, true);
755 
756   /* First record the real operands.  */
757   get_expr_operands (stmt, &TMR_BASE (expr), opf_use | (flags & opf_no_vops));
758   get_expr_operands (stmt, &TMR_INDEX (expr), opf_use | (flags & opf_no_vops));
759   get_expr_operands (stmt, &TMR_INDEX2 (expr), opf_use | (flags & opf_no_vops));
760 
761   add_virtual_operand (stmt, flags);
762 }
763 
764 
765 /* If STMT is a call that may clobber globals and other symbols that
766    escape, add them to the VDEF/VUSE lists for it.  */
767 
768 static void
769 maybe_add_call_vops (gimple stmt)
770 {
771   int call_flags = gimple_call_flags (stmt);
772 
773   /* If aliases have been computed already, add VDEF or VUSE
774      operands for all the symbols that have been found to be
775      call-clobbered.  */
776   if (!(call_flags & ECF_NOVOPS))
777     {
778       /* A 'pure' or a 'const' function never call-clobbers anything.
779 	 A 'noreturn' function might, but since we don't return anyway
780 	 there is no point in recording that.  */
781       if (!(call_flags & (ECF_PURE | ECF_CONST | ECF_NORETURN)))
782 	add_virtual_operand (stmt, opf_def);
783       else if (!(call_flags & ECF_CONST))
784 	add_virtual_operand (stmt, opf_use);
785     }
786 }
787 
788 
789 /* Scan operands in the ASM_EXPR stmt referred to in INFO.  */
790 
791 static void
792 get_asm_expr_operands (gimple stmt)
793 {
794   size_t i, noutputs;
795   const char **oconstraints;
796   const char *constraint;
797   bool allows_mem, allows_reg, is_inout;
798 
799   noutputs = gimple_asm_noutputs (stmt);
800   oconstraints = (const char **) alloca ((noutputs) * sizeof (const char *));
801 
802   /* Gather all output operands.  */
803   for (i = 0; i < gimple_asm_noutputs (stmt); i++)
804     {
805       tree link = gimple_asm_output_op (stmt, i);
806       constraint = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (link)));
807       oconstraints[i] = constraint;
808       parse_output_constraint (&constraint, i, 0, 0, &allows_mem,
809 	                       &allows_reg, &is_inout);
810 
811       /* This should have been split in gimplify_asm_expr.  */
812       gcc_assert (!allows_reg || !is_inout);
813 
814       /* Memory operands are addressable.  Note that STMT needs the
815 	 address of this operand.  */
816       if (!allows_reg && allows_mem)
817 	mark_address_taken (TREE_VALUE (link));
818 
819       get_expr_operands (stmt, &TREE_VALUE (link), opf_def | opf_not_non_addressable);
820     }
821 
822   /* Gather all input operands.  */
823   for (i = 0; i < gimple_asm_ninputs (stmt); i++)
824     {
825       tree link = gimple_asm_input_op (stmt, i);
826       constraint = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (link)));
827       parse_input_constraint (&constraint, 0, 0, noutputs, 0, oconstraints,
828 	                      &allows_mem, &allows_reg);
829 
830       /* Memory operands are addressable.  Note that STMT needs the
831 	 address of this operand.  */
832       if (!allows_reg && allows_mem)
833 	mark_address_taken (TREE_VALUE (link));
834 
835       get_expr_operands (stmt, &TREE_VALUE (link), opf_not_non_addressable);
836     }
837 
838   /* Clobber all memory and addressable symbols for asm ("" : : : "memory");  */
839   if (gimple_asm_clobbers_memory_p (stmt))
840     add_virtual_operand (stmt, opf_def);
841 }
842 
843 
844 /* Recursively scan the expression pointed to by EXPR_P in statement
845    STMT.  FLAGS is one of the OPF_* constants modifying how to
846    interpret the operands found.  */
847 
848 static void
849 get_expr_operands (gimple stmt, tree *expr_p, int flags)
850 {
851   enum tree_code code;
852   enum tree_code_class codeclass;
853   tree expr = *expr_p;
854   int uflags = opf_use;
855 
856   if (expr == NULL)
857     return;
858 
859   if (is_gimple_debug (stmt))
860     uflags |= (flags & opf_no_vops);
861 
862   code = TREE_CODE (expr);
863   codeclass = TREE_CODE_CLASS (code);
864 
865   switch (code)
866     {
867     case ADDR_EXPR:
868       /* Taking the address of a variable does not represent a
869 	 reference to it, but the fact that the statement takes its
870 	 address will be of interest to some passes (e.g. alias
871 	 resolution).  */
872       if ((!(flags & opf_non_addressable)
873 	   || (flags & opf_not_non_addressable))
874 	  && !is_gimple_debug (stmt))
875 	mark_address_taken (TREE_OPERAND (expr, 0));
876 
877       /* If the address is invariant, there may be no interesting
878 	 variable references inside.  */
879       if (is_gimple_min_invariant (expr))
880 	return;
881 
882       /* Otherwise, there may be variables referenced inside but there
883 	 should be no VUSEs created, since the referenced objects are
884 	 not really accessed.  The only operands that we should find
885 	 here are ARRAY_REF indices which will always be real operands
886 	 (GIMPLE does not allow non-registers as array indices).  */
887       flags |= opf_no_vops;
888       get_expr_operands (stmt, &TREE_OPERAND (expr, 0),
889 			 flags | opf_not_non_addressable);
890       return;
891 
892     case SSA_NAME:
893      add_stmt_operand (expr_p, stmt, flags);
894      return;
895 
896     case VAR_DECL:
897     case PARM_DECL:
898     case RESULT_DECL:
899       add_stmt_operand (expr_p, stmt, flags);
900       return;
901 
902     case DEBUG_EXPR_DECL:
903       gcc_assert (gimple_debug_bind_p (stmt));
904       return;
905 
906     case MEM_REF:
907       get_indirect_ref_operands (stmt, expr, flags, true);
908       return;
909 
910     case TARGET_MEM_REF:
911       get_tmr_operands (stmt, expr, flags);
912       return;
913 
914     case ARRAY_REF:
915     case ARRAY_RANGE_REF:
916     case COMPONENT_REF:
917     case REALPART_EXPR:
918     case IMAGPART_EXPR:
919       {
920 	if (!(flags & opf_no_vops)
921 	    && TREE_THIS_VOLATILE (expr))
922 	  gimple_set_has_volatile_ops (stmt, true);
923 
924 	get_expr_operands (stmt, &TREE_OPERAND (expr, 0), flags);
925 
926 	if (code == COMPONENT_REF)
927 	  {
928 	    if (!(flags & opf_no_vops)
929 		&& TREE_THIS_VOLATILE (TREE_OPERAND (expr, 1)))
930 	      gimple_set_has_volatile_ops (stmt, true);
931 	    get_expr_operands (stmt, &TREE_OPERAND (expr, 2), uflags);
932 	  }
933 	else if (code == ARRAY_REF || code == ARRAY_RANGE_REF)
934 	  {
935             get_expr_operands (stmt, &TREE_OPERAND (expr, 1), uflags);
936             get_expr_operands (stmt, &TREE_OPERAND (expr, 2), uflags);
937             get_expr_operands (stmt, &TREE_OPERAND (expr, 3), uflags);
938 	  }
939 
940 	return;
941       }
942 
943     case WITH_SIZE_EXPR:
944       /* WITH_SIZE_EXPR is a pass-through reference to its first argument,
945 	 and an rvalue reference to its second argument.  */
946       get_expr_operands (stmt, &TREE_OPERAND (expr, 1), uflags);
947       get_expr_operands (stmt, &TREE_OPERAND (expr, 0), flags);
948       return;
949 
950     case COND_EXPR:
951     case VEC_COND_EXPR:
952     case VEC_PERM_EXPR:
953       get_expr_operands (stmt, &TREE_OPERAND (expr, 0), uflags);
954       get_expr_operands (stmt, &TREE_OPERAND (expr, 1), uflags);
955       get_expr_operands (stmt, &TREE_OPERAND (expr, 2), uflags);
956       return;
957 
958     case CONSTRUCTOR:
959       {
960 	/* General aggregate CONSTRUCTORs have been decomposed, but they
961 	   are still in use as the COMPLEX_EXPR equivalent for vectors.  */
962 	constructor_elt *ce;
963 	unsigned HOST_WIDE_INT idx;
964 
965 	/* A volatile constructor is actually TREE_CLOBBER_P, transfer
966 	   the volatility to the statement, don't use TREE_CLOBBER_P for
967 	   mirroring the other uses of THIS_VOLATILE in this file.  */
968 	if (!(flags & opf_no_vops)
969 	    && TREE_THIS_VOLATILE (expr))
970 	  gimple_set_has_volatile_ops (stmt, true);
971 
972 	for (idx = 0;
973 	     VEC_iterate (constructor_elt, CONSTRUCTOR_ELTS (expr), idx, ce);
974 	     idx++)
975 	  get_expr_operands (stmt, &ce->value, uflags);
976 
977 	return;
978       }
979 
980     case BIT_FIELD_REF:
981       if (!(flags & opf_no_vops)
982 	  && TREE_THIS_VOLATILE (expr))
983 	gimple_set_has_volatile_ops (stmt, true);
984       /* FALLTHRU */
985 
986     case VIEW_CONVERT_EXPR:
987     do_unary:
988       get_expr_operands (stmt, &TREE_OPERAND (expr, 0), flags);
989       return;
990 
991     case COMPOUND_EXPR:
992     case OBJ_TYPE_REF:
993     case ASSERT_EXPR:
994     do_binary:
995       {
996 	get_expr_operands (stmt, &TREE_OPERAND (expr, 0), flags);
997 	get_expr_operands (stmt, &TREE_OPERAND (expr, 1), flags);
998 	return;
999       }
1000 
1001     case DOT_PROD_EXPR:
1002     case REALIGN_LOAD_EXPR:
1003     case WIDEN_MULT_PLUS_EXPR:
1004     case WIDEN_MULT_MINUS_EXPR:
1005     case FMA_EXPR:
1006       {
1007 	get_expr_operands (stmt, &TREE_OPERAND (expr, 0), flags);
1008 	get_expr_operands (stmt, &TREE_OPERAND (expr, 1), flags);
1009 	get_expr_operands (stmt, &TREE_OPERAND (expr, 2), flags);
1010 	return;
1011       }
1012 
1013     case FUNCTION_DECL:
1014     case LABEL_DECL:
1015     case CONST_DECL:
1016     case CASE_LABEL_EXPR:
1017       /* Expressions that make no memory references.  */
1018       return;
1019 
1020     default:
1021       if (codeclass == tcc_unary)
1022 	goto do_unary;
1023       if (codeclass == tcc_binary || codeclass == tcc_comparison)
1024 	goto do_binary;
1025       if (codeclass == tcc_constant || codeclass == tcc_type)
1026 	return;
1027     }
1028 
1029   /* If we get here, something has gone wrong.  */
1030 #ifdef ENABLE_CHECKING
1031   fprintf (stderr, "unhandled expression in get_expr_operands():\n");
1032   debug_tree (expr);
1033   fputs ("\n", stderr);
1034 #endif
1035   gcc_unreachable ();
1036 }
1037 
1038 
1039 /* Parse STMT looking for operands.  When finished, the various
1040    build_* operand vectors will have potential operands in them.  */
1041 
1042 static void
1043 parse_ssa_operands (gimple stmt)
1044 {
1045   enum gimple_code code = gimple_code (stmt);
1046   size_t i, n, start = 0;
1047 
1048   switch (code)
1049     {
1050     case GIMPLE_ASM:
1051       get_asm_expr_operands (stmt);
1052       break;
1053 
1054     case GIMPLE_TRANSACTION:
1055       /* The start of a transaction is a memory barrier.  */
1056       add_virtual_operand (stmt, opf_def | opf_use);
1057       break;
1058 
1059     case GIMPLE_DEBUG:
1060       if (gimple_debug_bind_p (stmt)
1061 	  && gimple_debug_bind_has_value_p (stmt))
1062 	get_expr_operands (stmt, gimple_debug_bind_get_value_ptr (stmt),
1063 			   opf_use | opf_no_vops);
1064       break;
1065 
1066     case GIMPLE_RETURN:
1067       append_vuse (gimple_vop (cfun));
1068       goto do_default;
1069 
1070     case GIMPLE_CALL:
1071       /* Add call-clobbered operands, if needed.  */
1072       maybe_add_call_vops (stmt);
1073       /* FALLTHRU */
1074 
1075     case GIMPLE_ASSIGN:
1076       get_expr_operands (stmt, gimple_op_ptr (stmt, 0), opf_def);
1077       start = 1;
1078       /* FALLTHRU */
1079 
1080     default:
1081     do_default:
1082       n = gimple_num_ops (stmt);
1083       for (i = start; i < n; i++)
1084 	get_expr_operands (stmt, gimple_op_ptr (stmt, i), opf_use);
1085       break;
1086     }
1087 }
1088 
1089 
1090 /* Create an operands cache for STMT.  */
1091 
1092 static void
1093 build_ssa_operands (gimple stmt)
1094 {
1095   /* Initially assume that the statement has no volatile operands.  */
1096   gimple_set_has_volatile_ops (stmt, false);
1097 
1098   start_ssa_stmt_operands ();
1099   parse_ssa_operands (stmt);
1100   finalize_ssa_stmt_operands (stmt);
1101 }
1102 
1103 /* Verifies SSA statement operands.  */
1104 
1105 DEBUG_FUNCTION bool
1106 verify_ssa_operands (gimple stmt)
1107 {
1108   use_operand_p use_p;
1109   def_operand_p def_p;
1110   ssa_op_iter iter;
1111   unsigned i;
1112   tree use, def;
1113   bool volatile_p = gimple_has_volatile_ops (stmt);
1114 
1115   /* build_ssa_operands w/o finalizing them.  */
1116   gimple_set_has_volatile_ops (stmt, false);
1117   start_ssa_stmt_operands ();
1118   parse_ssa_operands (stmt);
1119 
1120   /* Now verify the built operands are the same as present in STMT.  */
1121   def = gimple_vdef (stmt);
1122   if (def
1123       && TREE_CODE (def) == SSA_NAME)
1124     def = SSA_NAME_VAR (def);
1125   if (build_vdef != def)
1126     {
1127       error ("virtual definition of statement not up-to-date");
1128       return true;
1129     }
1130   if (gimple_vdef (stmt)
1131       && ((def_p = gimple_vdef_op (stmt)) == NULL_DEF_OPERAND_P
1132 	  || DEF_FROM_PTR (def_p) != gimple_vdef (stmt)))
1133     {
1134       error ("virtual def operand missing for stmt");
1135       return true;
1136     }
1137 
1138   use = gimple_vuse (stmt);
1139   if (use
1140       && TREE_CODE (use) == SSA_NAME)
1141     use = SSA_NAME_VAR (use);
1142   if (build_vuse != use)
1143     {
1144       error ("virtual use of statement not up-to-date");
1145       return true;
1146     }
1147   if (gimple_vuse (stmt)
1148       && ((use_p = gimple_vuse_op (stmt)) == NULL_USE_OPERAND_P
1149 	  || USE_FROM_PTR (use_p) != gimple_vuse (stmt)))
1150     {
1151       error ("virtual use operand missing for stmt");
1152       return true;
1153     }
1154 
1155   FOR_EACH_SSA_USE_OPERAND (use_p, stmt, iter, SSA_OP_USE)
1156     {
1157       FOR_EACH_VEC_ELT (tree, build_uses, i, use)
1158 	{
1159 	  if (use_p->use == (tree *)use)
1160 	    {
1161 	      VEC_replace (tree, build_uses, i, NULL_TREE);
1162 	      break;
1163 	    }
1164 	}
1165       if (i == VEC_length (tree, build_uses))
1166 	{
1167 	  error ("excess use operand for stmt");
1168 	  debug_generic_expr (USE_FROM_PTR (use_p));
1169 	  return true;
1170 	}
1171     }
1172   FOR_EACH_VEC_ELT (tree, build_uses, i, use)
1173     if (use != NULL_TREE)
1174       {
1175 	error ("use operand missing for stmt");
1176 	debug_generic_expr (*(tree *)use);
1177 	return true;
1178       }
1179 
1180   FOR_EACH_SSA_DEF_OPERAND (def_p, stmt, iter, SSA_OP_DEF)
1181     {
1182       FOR_EACH_VEC_ELT (tree, build_defs, i, def)
1183 	{
1184 	  if (def_p == (tree *)def)
1185 	    {
1186 	      VEC_replace (tree, build_defs, i, NULL_TREE);
1187 	      break;
1188 	    }
1189 	}
1190       if (i == VEC_length (tree, build_defs))
1191 	{
1192 	  error ("excess def operand for stmt");
1193 	  debug_generic_expr (DEF_FROM_PTR (def_p));
1194 	  return true;
1195 	}
1196     }
1197   FOR_EACH_VEC_ELT (tree, build_defs, i, def)
1198     if (def != NULL_TREE)
1199       {
1200 	error ("def operand missing for stmt");
1201 	debug_generic_expr (*(tree *)def);
1202 	return true;
1203       }
1204 
1205   if (gimple_has_volatile_ops (stmt) != volatile_p)
1206     {
1207       error ("stmt volatile flag not up-to-date");
1208       return true;
1209     }
1210 
1211   cleanup_build_arrays ();
1212   return false;
1213 }
1214 
1215 
1216 /* Releases the operands of STMT back to their freelists, and clears
1217    the stmt operand lists.  */
1218 
1219 void
1220 free_stmt_operands (gimple stmt)
1221 {
1222   def_optype_p defs = gimple_def_ops (stmt), last_def;
1223   use_optype_p uses = gimple_use_ops (stmt), last_use;
1224 
1225   if (defs)
1226     {
1227       for (last_def = defs; last_def->next; last_def = last_def->next)
1228 	continue;
1229       last_def->next = gimple_ssa_operands (cfun)->free_defs;
1230       gimple_ssa_operands (cfun)->free_defs = defs;
1231       gimple_set_def_ops (stmt, NULL);
1232     }
1233 
1234   if (uses)
1235     {
1236       for (last_use = uses; last_use->next; last_use = last_use->next)
1237 	delink_imm_use (USE_OP_PTR (last_use));
1238       delink_imm_use (USE_OP_PTR (last_use));
1239       last_use->next = gimple_ssa_operands (cfun)->free_uses;
1240       gimple_ssa_operands (cfun)->free_uses = uses;
1241       gimple_set_use_ops (stmt, NULL);
1242     }
1243 
1244   if (gimple_has_mem_ops (stmt))
1245     {
1246       gimple_set_vuse (stmt, NULL_TREE);
1247       gimple_set_vdef (stmt, NULL_TREE);
1248     }
1249 }
1250 
1251 
1252 /* Get the operands of statement STMT.  */
1253 
1254 void
1255 update_stmt_operands (gimple stmt)
1256 {
1257   /* If update_stmt_operands is called before SSA is initialized, do
1258      nothing.  */
1259   if (!ssa_operands_active ())
1260     return;
1261 
1262   timevar_push (TV_TREE_OPS);
1263 
1264   /* If the stmt is a noreturn call queue it to be processed by
1265      split_bbs_on_noreturn_calls during cfg cleanup.  */
1266   if (is_gimple_call (stmt)
1267       && gimple_call_noreturn_p (stmt))
1268     VEC_safe_push (gimple, gc, MODIFIED_NORETURN_CALLS (cfun), stmt);
1269 
1270   gcc_assert (gimple_modified_p (stmt));
1271   build_ssa_operands (stmt);
1272   gimple_set_modified (stmt, false);
1273 
1274   timevar_pop (TV_TREE_OPS);
1275 }
1276 
1277 
1278 /* Swap operands EXP0 and EXP1 in statement STMT.  No attempt is done
1279    to test the validity of the swap operation.  */
1280 
1281 void
1282 swap_tree_operands (gimple stmt, tree *exp0, tree *exp1)
1283 {
1284   tree op0, op1;
1285   op0 = *exp0;
1286   op1 = *exp1;
1287 
1288   /* If the operand cache is active, attempt to preserve the relative
1289      positions of these two operands in their respective immediate use
1290      lists by adjusting their use pointer to point to the new
1291      operand position.  */
1292   if (ssa_operands_active () && op0 != op1)
1293     {
1294       use_optype_p use0, use1, ptr;
1295       use0 = use1 = NULL;
1296 
1297       /* Find the 2 operands in the cache, if they are there.  */
1298       for (ptr = gimple_use_ops (stmt); ptr; ptr = ptr->next)
1299 	if (USE_OP_PTR (ptr)->use == exp0)
1300 	  {
1301 	    use0 = ptr;
1302 	    break;
1303 	  }
1304 
1305       for (ptr = gimple_use_ops (stmt); ptr; ptr = ptr->next)
1306 	if (USE_OP_PTR (ptr)->use == exp1)
1307 	  {
1308 	    use1 = ptr;
1309 	    break;
1310 	  }
1311 
1312       /* And adjust their location to point to the new position of the
1313          operand.  */
1314       if (use0)
1315 	USE_OP_PTR (use0)->use = exp1;
1316       if (use1)
1317 	USE_OP_PTR (use1)->use = exp0;
1318     }
1319 
1320   /* Now swap the data.  */
1321   *exp0 = op1;
1322   *exp1 = op0;
1323 }
1324 
1325 
1326 /* Scan the immediate_use list for VAR making sure its linked properly.
1327    Return TRUE if there is a problem and emit an error message to F.  */
1328 
1329 DEBUG_FUNCTION bool
1330 verify_imm_links (FILE *f, tree var)
1331 {
1332   use_operand_p ptr, prev, list;
1333   int count;
1334 
1335   gcc_assert (TREE_CODE (var) == SSA_NAME);
1336 
1337   list = &(SSA_NAME_IMM_USE_NODE (var));
1338   gcc_assert (list->use == NULL);
1339 
1340   if (list->prev == NULL)
1341     {
1342       gcc_assert (list->next == NULL);
1343       return false;
1344     }
1345 
1346   prev = list;
1347   count = 0;
1348   for (ptr = list->next; ptr != list; )
1349     {
1350       if (prev != ptr->prev)
1351 	goto error;
1352 
1353       if (ptr->use == NULL)
1354 	goto error; /* 2 roots, or SAFE guard node.  */
1355       else if (*(ptr->use) != var)
1356 	goto error;
1357 
1358       prev = ptr;
1359       ptr = ptr->next;
1360 
1361       /* Avoid infinite loops.  50,000,000 uses probably indicates a
1362 	 problem.  */
1363       if (count++ > 50000000)
1364 	goto error;
1365     }
1366 
1367   /* Verify list in the other direction.  */
1368   prev = list;
1369   for (ptr = list->prev; ptr != list; )
1370     {
1371       if (prev != ptr->next)
1372 	goto error;
1373       prev = ptr;
1374       ptr = ptr->prev;
1375       if (count-- < 0)
1376 	goto error;
1377     }
1378 
1379   if (count != 0)
1380     goto error;
1381 
1382   return false;
1383 
1384  error:
1385   if (ptr->loc.stmt && gimple_modified_p (ptr->loc.stmt))
1386     {
1387       fprintf (f, " STMT MODIFIED. - <%p> ", (void *)ptr->loc.stmt);
1388       print_gimple_stmt (f, ptr->loc.stmt, 0, TDF_SLIM);
1389     }
1390   fprintf (f, " IMM ERROR : (use_p : tree - %p:%p)", (void *)ptr,
1391 	   (void *)ptr->use);
1392   print_generic_expr (f, USE_FROM_PTR (ptr), TDF_SLIM);
1393   fprintf(f, "\n");
1394   return true;
1395 }
1396 
1397 
1398 /* Dump all the immediate uses to FILE.  */
1399 
1400 void
1401 dump_immediate_uses_for (FILE *file, tree var)
1402 {
1403   imm_use_iterator iter;
1404   use_operand_p use_p;
1405 
1406   gcc_assert (var && TREE_CODE (var) == SSA_NAME);
1407 
1408   print_generic_expr (file, var, TDF_SLIM);
1409   fprintf (file, " : -->");
1410   if (has_zero_uses (var))
1411     fprintf (file, " no uses.\n");
1412   else
1413     if (has_single_use (var))
1414       fprintf (file, " single use.\n");
1415     else
1416       fprintf (file, "%d uses.\n", num_imm_uses (var));
1417 
1418   FOR_EACH_IMM_USE_FAST (use_p, iter, var)
1419     {
1420       if (use_p->loc.stmt == NULL && use_p->use == NULL)
1421         fprintf (file, "***end of stmt iterator marker***\n");
1422       else
1423 	if (!is_gimple_reg (USE_FROM_PTR (use_p)))
1424 	  print_gimple_stmt (file, USE_STMT (use_p), 0, TDF_VOPS|TDF_MEMSYMS);
1425 	else
1426 	  print_gimple_stmt (file, USE_STMT (use_p), 0, TDF_SLIM);
1427     }
1428   fprintf(file, "\n");
1429 }
1430 
1431 
1432 /* Dump all the immediate uses to FILE.  */
1433 
1434 void
1435 dump_immediate_uses (FILE *file)
1436 {
1437   tree var;
1438   unsigned int x;
1439 
1440   fprintf (file, "Immediate_uses: \n\n");
1441   for (x = 1; x < num_ssa_names; x++)
1442     {
1443       var = ssa_name(x);
1444       if (!var)
1445         continue;
1446       dump_immediate_uses_for (file, var);
1447     }
1448 }
1449 
1450 
1451 /* Dump def-use edges on stderr.  */
1452 
1453 DEBUG_FUNCTION void
1454 debug_immediate_uses (void)
1455 {
1456   dump_immediate_uses (stderr);
1457 }
1458 
1459 
1460 /* Dump def-use edges on stderr.  */
1461 
1462 DEBUG_FUNCTION void
1463 debug_immediate_uses_for (tree var)
1464 {
1465   dump_immediate_uses_for (stderr, var);
1466 }
1467 
1468 
1469 /* Unlink STMTs virtual definition from the IL by propagating its use.  */
1470 
1471 void
1472 unlink_stmt_vdef (gimple stmt)
1473 {
1474   use_operand_p use_p;
1475   imm_use_iterator iter;
1476   gimple use_stmt;
1477   tree vdef = gimple_vdef (stmt);
1478 
1479   if (!vdef
1480       || TREE_CODE (vdef) != SSA_NAME)
1481     return;
1482 
1483   FOR_EACH_IMM_USE_STMT (use_stmt, iter, gimple_vdef (stmt))
1484     {
1485       FOR_EACH_IMM_USE_ON_STMT (use_p, iter)
1486 	SET_USE (use_p, gimple_vuse (stmt));
1487     }
1488 
1489   if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (gimple_vdef (stmt)))
1490     SSA_NAME_OCCURS_IN_ABNORMAL_PHI (gimple_vuse (stmt)) = 1;
1491 }
1492 
1493