gcc/tree-ssa-operands.c

   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 "toplev.h"
  36 #include "langhooks.h"
  37 #include "ipa-reference.h"
  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 (TREE_THIS_VOLATILE (sym))
 672     gimple_set_has_volatile_ops (stmt, true);
 673
 674   if (is_gimple_reg (sym))
 675     {
 676       /* The variable is a GIMPLE register.  Add it to real operands.  */
 677       if (flags & opf_def)
 678         append_def (var_p);
 679       else
 680         append_use (var_p);
 681     }
 682   else
 683     add_virtual_operand (stmt, flags);
 684 }
 685
 686 /* Mark the base address of REF as having its address taken.
 687    REF may be a single variable whose address has been taken or any
 688    other valid GIMPLE memory reference (structure reference, array,
 689    etc).  */
 690
 691 static void
 692 mark_address_taken (tree ref)
 693 {
 694   tree var;
 695
 696   /* Note that it is *NOT OKAY* to use the target of a COMPONENT_REF
 697      as the only thing we take the address of.  If VAR is a structure,
 698      taking the address of a field means that the whole structure may
 699      be referenced using pointer arithmetic.  See PR 21407 and the
 700      ensuing mailing list discussion.  */
 701   var = get_base_address (ref);
 702   if (var)
 703     {
 704       if (DECL_P (var))
 705         TREE_ADDRESSABLE (var) = 1;
 706       else if (TREE_CODE (var) == MEM_REF
 707                && TREE_CODE (TREE_OPERAND (var, 0)) == ADDR_EXPR
 708                && DECL_P (TREE_OPERAND (TREE_OPERAND (var, 0), 0)))
 709         TREE_ADDRESSABLE (TREE_OPERAND (TREE_OPERAND (var, 0), 0)) = 1;
 710     }
 711 }
 712
 713
 714 /* A subroutine of get_expr_operands to handle MEM_REF.
 715
 716    STMT is the statement being processed, EXPR is the MEM_REF
 717       that got us here.
 718
 719    FLAGS is as in get_expr_operands.
 720
 721    RECURSE_ON_BASE should be set to true if we want to continue
 722       calling get_expr_operands on the base pointer, and false if
 723       something else will do it for us.  */
 724
 725 static void
 726 get_indirect_ref_operands (gimple stmt, tree expr, int flags,
 727                            bool recurse_on_base)
 728 {
 729   tree *pptr = &TREE_OPERAND (expr, 0);
 730
 731   if (TREE_THIS_VOLATILE (expr))
 732     gimple_set_has_volatile_ops (stmt, true);
 733
 734   /* Add the VOP.  */
 735   add_virtual_operand (stmt, flags);
 736
 737   /* If requested, add a USE operand for the base pointer.  */
 738   if (recurse_on_base)
 739     get_expr_operands (stmt, pptr,
 740                        opf_non_addressable | opf_use
 741                        | (flags & (opf_no_vops|opf_not_non_addressable)));
 742 }
 743
 744
 745 /* A subroutine of get_expr_operands to handle TARGET_MEM_REF.  */
 746
 747 static void
 748 get_tmr_operands (gimple stmt, tree expr, int flags)
 749 {
 750   if (TREE_THIS_VOLATILE (expr))
 751     gimple_set_has_volatile_ops (stmt, true);
 752
 753   /* First record the real operands.  */
 754   get_expr_operands (stmt, &TMR_BASE (expr), opf_use | (flags & opf_no_vops));
 755   get_expr_operands (stmt, &TMR_INDEX (expr), opf_use | (flags & opf_no_vops));
 756   get_expr_operands (stmt, &TMR_INDEX2 (expr), opf_use | (flags & opf_no_vops));
 757
 758   add_virtual_operand (stmt, flags);
 759 }
 760
 761
 762 /* If STMT is a call that may clobber globals and other symbols that
 763    escape, add them to the VDEF/VUSE lists for it.  */
 764
 765 static void
 766 maybe_add_call_vops (gimple stmt)
 767 {
 768   int call_flags = gimple_call_flags (stmt);
 769
 770   /* If aliases have been computed already, add VDEF or VUSE
 771      operands for all the symbols that have been found to be
 772      call-clobbered.  */
 773   if (!(call_flags & ECF_NOVOPS))
 774     {
 775       /* A 'pure' or a 'const' function never call-clobbers anything.
 776          A 'noreturn' function might, but since we don't return anyway
 777          there is no point in recording that.  */
 778       if (!(call_flags & (ECF_PURE | ECF_CONST | ECF_NORETURN)))
 779         add_virtual_operand (stmt, opf_def);
 780       else if (!(call_flags & ECF_CONST))
 781         add_virtual_operand (stmt, opf_use);
 782     }
 783 }
 784
 785
 786 /* Scan operands in the ASM_EXPR stmt referred to in INFO.  */
 787
 788 static void
 789 get_asm_expr_operands (gimple stmt)
 790 {
 791   size_t i, noutputs;
 792   const char **oconstraints;
 793   const char *constraint;
 794   bool allows_mem, allows_reg, is_inout;
 795
 796   noutputs = gimple_asm_noutputs (stmt);
 797   oconstraints = (const char **) alloca ((noutputs) * sizeof (const char *));
 798
 799   /* Gather all output operands.  */
 800   for (i = 0; i < gimple_asm_noutputs (stmt); i++)
 801     {
 802       tree link = gimple_asm_output_op (stmt, i);
 803       constraint = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (link)));
 804       oconstraints[i] = constraint;
 805       parse_output_constraint (&constraint, i, 0, 0, &allows_mem,
 806                                &allows_reg, &is_inout);
 807
 808       /* This should have been split in gimplify_asm_expr.  */
 809       gcc_assert (!allows_reg || !is_inout);
 810
 811       /* Memory operands are addressable.  Note that STMT needs the
 812          address of this operand.  */
 813       if (!allows_reg && allows_mem)
 814         mark_address_taken (TREE_VALUE (link));
 815
 816       get_expr_operands (stmt, &TREE_VALUE (link), opf_def | opf_not_non_addressable);
 817     }
 818
 819   /* Gather all input operands.  */
 820   for (i = 0; i < gimple_asm_ninputs (stmt); i++)
 821     {
 822       tree link = gimple_asm_input_op (stmt, i);
 823       constraint = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (link)));
 824       parse_input_constraint (&constraint, 0, 0, noutputs, 0, oconstraints,
 825                               &allows_mem, &allows_reg);
 826
 827       /* Memory operands are addressable.  Note that STMT needs the
 828          address of this operand.  */
 829       if (!allows_reg && allows_mem)
 830         mark_address_taken (TREE_VALUE (link));
 831
 832       get_expr_operands (stmt, &TREE_VALUE (link), opf_not_non_addressable);
 833     }
 834
 835   /* Clobber all memory and addressable symbols for asm ("" : : : "memory");  */
 836   for (i = 0; i < gimple_asm_nclobbers (stmt); i++)
 837     {
 838       tree link = gimple_asm_clobber_op (stmt, i);
 839       if (strcmp (TREE_STRING_POINTER (TREE_VALUE (link)), "memory") == 0)
 840         {
 841           add_virtual_operand (stmt, opf_def);
 842           break;
 843         }
 844     }
 845 }
 846
 847
 848 /* Recursively scan the expression pointed to by EXPR_P in statement
 849    STMT.  FLAGS is one of the OPF_* constants modifying how to
 850    interpret the operands found.  */
 851
 852 static void
 853 get_expr_operands (gimple stmt, tree *expr_p, int flags)
 854 {
 855   enum tree_code code;
 856   enum tree_code_class codeclass;
 857   tree expr = *expr_p;
 858   int uflags = opf_use;
 859
 860   if (expr == NULL)
 861     return;
 862
 863   if (is_gimple_debug (stmt))
 864     uflags |= (flags & opf_no_vops);
 865
 866   code = TREE_CODE (expr);
 867   codeclass = TREE_CODE_CLASS (code);
 868
 869   switch (code)
 870     {
 871     case ADDR_EXPR:
 872       /* Taking the address of a variable does not represent a
 873          reference to it, but the fact that the statement takes its
 874          address will be of interest to some passes (e.g. alias
 875          resolution).  */
 876       if ((!(flags & opf_non_addressable)
 877            || (flags & opf_not_non_addressable))
 878           && !is_gimple_debug (stmt))
 879         mark_address_taken (TREE_OPERAND (expr, 0));
 880
 881       /* If the address is invariant, there may be no interesting
 882          variable references inside.  */
 883       if (is_gimple_min_invariant (expr))
 884         return;
 885
 886       /* Otherwise, there may be variables referenced inside but there
 887          should be no VUSEs created, since the referenced objects are
 888          not really accessed.  The only operands that we should find
 889          here are ARRAY_REF indices which will always be real operands
 890          (GIMPLE does not allow non-registers as array indices).  */
 891       flags |= opf_no_vops;
 892       get_expr_operands (stmt, &TREE_OPERAND (expr, 0),
 893                          flags | opf_not_non_addressable);
 894       return;
 895
 896     case SSA_NAME:
 897      add_stmt_operand (expr_p, stmt, flags);
 898      return;
 899
 900     case VAR_DECL:
 901     case PARM_DECL:
 902     case RESULT_DECL:
 903       add_stmt_operand (expr_p, stmt, flags);
 904       return;
 905
 906     case DEBUG_EXPR_DECL:
 907       gcc_assert (gimple_debug_bind_p (stmt));
 908       return;
 909
 910     case MEM_REF:
 911       get_indirect_ref_operands (stmt, expr, flags, true);
 912       return;
 913
 914     case TARGET_MEM_REF:
 915       get_tmr_operands (stmt, expr, flags);
 916       return;
 917
 918     case ARRAY_REF:
 919     case ARRAY_RANGE_REF:
 920     case COMPONENT_REF:
 921     case REALPART_EXPR:
 922     case IMAGPART_EXPR:
 923       {
 924         if (TREE_THIS_VOLATILE (expr))
 925           gimple_set_has_volatile_ops (stmt, true);
 926
 927         get_expr_operands (stmt, &TREE_OPERAND (expr, 0), flags);
 928
 929         if (code == COMPONENT_REF)
 930           {
 931             if (TREE_THIS_VOLATILE (TREE_OPERAND (expr, 1)))
 932               gimple_set_has_volatile_ops (stmt, true);
 933             get_expr_operands (stmt, &TREE_OPERAND (expr, 2), uflags);
 934           }
 935         else if (code == ARRAY_REF || code == ARRAY_RANGE_REF)
 936           {
 937             get_expr_operands (stmt, &TREE_OPERAND (expr, 1), uflags);
 938             get_expr_operands (stmt, &TREE_OPERAND (expr, 2), uflags);
 939             get_expr_operands (stmt, &TREE_OPERAND (expr, 3), uflags);
 940           }
 941
 942         return;
 943       }
 944
 945     case WITH_SIZE_EXPR:
 946       /* WITH_SIZE_EXPR is a pass-through reference to its first argument,
 947          and an rvalue reference to its second argument.  */
 948       get_expr_operands (stmt, &TREE_OPERAND (expr, 1), uflags);
 949       get_expr_operands (stmt, &TREE_OPERAND (expr, 0), flags);
 950       return;
 951
 952     case COND_EXPR:
 953     case VEC_COND_EXPR:
 954       get_expr_operands (stmt, &TREE_OPERAND (expr, 0), uflags);
 955       get_expr_operands (stmt, &TREE_OPERAND (expr, 1), uflags);
 956       get_expr_operands (stmt, &TREE_OPERAND (expr, 2), uflags);
 957       return;
 958
 959     case CONSTRUCTOR:
 960       {
 961         /* General aggregate CONSTRUCTORs have been decomposed, but they
 962            are still in use as the COMPLEX_EXPR equivalent for vectors.  */
 963         constructor_elt *ce;
 964         unsigned HOST_WIDE_INT idx;
 965
 966         for (idx = 0;
 967              VEC_iterate (constructor_elt, CONSTRUCTOR_ELTS (expr), idx, ce);
 968              idx++)
 969           get_expr_operands (stmt, &ce->value, uflags);
 970
 971         return;
 972       }
 973
 974     case BIT_FIELD_REF:
 975       if (TREE_THIS_VOLATILE (expr))
 976         gimple_set_has_volatile_ops (stmt, true);
 977       /* FALLTHRU */
 978
 979     case TRUTH_NOT_EXPR:
 980     case VIEW_CONVERT_EXPR:
 981     do_unary:
 982       get_expr_operands (stmt, &TREE_OPERAND (expr, 0), flags);
 983       return;
 984
 985     case TRUTH_AND_EXPR:
 986     case TRUTH_OR_EXPR:
 987     case TRUTH_XOR_EXPR:
 988     case COMPOUND_EXPR:
 989     case OBJ_TYPE_REF:
 990     case ASSERT_EXPR:
 991     do_binary:
 992       {
 993         get_expr_operands (stmt, &TREE_OPERAND (expr, 0), flags);
 994         get_expr_operands (stmt, &TREE_OPERAND (expr, 1), flags);
 995         return;
 996       }
 997
 998     case DOT_PROD_EXPR:
 999     case REALIGN_LOAD_EXPR:
1000     case WIDEN_MULT_PLUS_EXPR:
1001     case WIDEN_MULT_MINUS_EXPR:
1002       {
1003         get_expr_operands (stmt, &TREE_OPERAND (expr, 0), flags);
1004         get_expr_operands (stmt, &TREE_OPERAND (expr, 1), flags);
1005         get_expr_operands (stmt, &TREE_OPERAND (expr, 2), flags);
1006         return;
1007       }
1008
1009     case FUNCTION_DECL:
1010     case LABEL_DECL:
1011     case CONST_DECL:
1012     case CASE_LABEL_EXPR:
1013       /* Expressions that make no memory references.  */
1014       return;
1015
1016     default:
1017       if (codeclass == tcc_unary)
1018         goto do_unary;
1019       if (codeclass == tcc_binary || codeclass == tcc_comparison)
1020         goto do_binary;
1021       if (codeclass == tcc_constant || codeclass == tcc_type)
1022         return;
1023     }
1024
1025   /* If we get here, something has gone wrong.  */
1026 #ifdef ENABLE_CHECKING
1027   fprintf (stderr, "unhandled expression in get_expr_operands():\n");
1028   debug_tree (expr);
1029   fputs ("\n", stderr);
1030 #endif
1031   gcc_unreachable ();
1032 }
1033
1034
1035 /* Parse STMT looking for operands.  When finished, the various
1036    build_* operand vectors will have potential operands in them.  */
1037
1038 static void
1039 parse_ssa_operands (gimple stmt)
1040 {
1041   enum gimple_code code = gimple_code (stmt);
1042
1043   if (code == GIMPLE_ASM)
1044     get_asm_expr_operands (stmt);
1045   else if (is_gimple_debug (stmt))
1046     {
1047       if (gimple_debug_bind_p (stmt)
1048           && gimple_debug_bind_has_value_p (stmt))
1049         get_expr_operands (stmt, gimple_debug_bind_get_value_ptr (stmt),
1050                            opf_use | opf_no_vops);
1051     }
1052   else
1053     {
1054       size_t i, start = 0;
1055
1056       if (code == GIMPLE_ASSIGN || code == GIMPLE_CALL)
1057         {
1058           get_expr_operands (stmt, gimple_op_ptr (stmt, 0), opf_def);
1059           start = 1;
1060         }
1061
1062       for (i = start; i < gimple_num_ops (stmt); i++)
1063         get_expr_operands (stmt, gimple_op_ptr (stmt, i), opf_use);
1064
1065       /* Add call-clobbered operands, if needed.  */
1066       if (code == GIMPLE_CALL)
1067         maybe_add_call_vops (stmt);
1068     }
1069 }
1070
1071
1072 /* Create an operands cache for STMT.  */
1073
1074 static void
1075 build_ssa_operands (gimple stmt)
1076 {
1077   /* Initially assume that the statement has no volatile operands.  */
1078   gimple_set_has_volatile_ops (stmt, false);
1079
1080   start_ssa_stmt_operands ();
1081   parse_ssa_operands (stmt);
1082   finalize_ssa_stmt_operands (stmt);
1083 }
1084
1085
1086 /* Releases the operands of STMT back to their freelists, and clears
1087    the stmt operand lists.  */
1088
1089 void
1090 free_stmt_operands (gimple stmt)
1091 {
1092   def_optype_p defs = gimple_def_ops (stmt), last_def;
1093   use_optype_p uses = gimple_use_ops (stmt), last_use;
1094
1095   if (defs)
1096     {
1097       for (last_def = defs; last_def->next; last_def = last_def->next)
1098         continue;
1099       last_def->next = gimple_ssa_operands (cfun)->free_defs;
1100       gimple_ssa_operands (cfun)->free_defs = defs;
1101       gimple_set_def_ops (stmt, NULL);
1102     }
1103
1104   if (uses)
1105     {
1106       for (last_use = uses; last_use->next; last_use = last_use->next)
1107         delink_imm_use (USE_OP_PTR (last_use));
1108       delink_imm_use (USE_OP_PTR (last_use));
1109       last_use->next = gimple_ssa_operands (cfun)->free_uses;
1110       gimple_ssa_operands (cfun)->free_uses = uses;
1111       gimple_set_use_ops (stmt, NULL);
1112     }
1113
1114   if (gimple_has_mem_ops (stmt))
1115     {
1116       gimple_set_vuse (stmt, NULL_TREE);
1117       gimple_set_vdef (stmt, NULL_TREE);
1118     }
1119 }
1120
1121
1122 /* Get the operands of statement STMT.  */
1123
1124 void
1125 update_stmt_operands (gimple stmt)
1126 {
1127   /* If update_stmt_operands is called before SSA is initialized, do
1128      nothing.  */
1129   if (!ssa_operands_active ())
1130     return;
1131
1132   timevar_push (TV_TREE_OPS);
1133
1134   gcc_assert (gimple_modified_p (stmt));
1135   build_ssa_operands (stmt);
1136   gimple_set_modified (stmt, false);
1137
1138   timevar_pop (TV_TREE_OPS);
1139 }
1140
1141
1142 /* Swap operands EXP0 and EXP1 in statement STMT.  No attempt is done
1143    to test the validity of the swap operation.  */
1144
1145 void
1146 swap_tree_operands (gimple stmt, tree *exp0, tree *exp1)
1147 {
1148   tree op0, op1;
1149   op0 = *exp0;
1150   op1 = *exp1;
1151
1152   /* If the operand cache is active, attempt to preserve the relative
1153      positions of these two operands in their respective immediate use
1154      lists.  */
1155   if (ssa_operands_active () && op0 != op1)
1156     {
1157       use_optype_p use0, use1, ptr;
1158       use0 = use1 = NULL;
1159
1160       /* Find the 2 operands in the cache, if they are there.  */
1161       for (ptr = gimple_use_ops (stmt); ptr; ptr = ptr->next)
1162         if (USE_OP_PTR (ptr)->use == exp0)
1163           {
1164             use0 = ptr;
1165             break;
1166           }
1167
1168       for (ptr = gimple_use_ops (stmt); ptr; ptr = ptr->next)
1169         if (USE_OP_PTR (ptr)->use == exp1)
1170           {
1171             use1 = ptr;
1172             break;
1173           }
1174
1175       /* If both uses don't have operand entries, there isn't much we can do
1176          at this point.  Presumably we don't need to worry about it.  */
1177       if (use0 && use1)
1178         {
1179           tree *tmp = USE_OP_PTR (use1)->use;
1180           USE_OP_PTR (use1)->use = USE_OP_PTR (use0)->use;
1181           USE_OP_PTR (use0)->use = tmp;
1182         }
1183     }
1184
1185   /* Now swap the data.  */
1186   *exp0 = op1;
1187   *exp1 = op0;
1188 }
1189
1190
1191 /* Scan the immediate_use list for VAR making sure its linked properly.
1192    Return TRUE if there is a problem and emit an error message to F.  */
1193
1194 DEBUG_FUNCTION bool
1195 verify_imm_links (FILE *f, tree var)
1196 {
1197   use_operand_p ptr, prev, list;
1198   int count;
1199
1200   gcc_assert (TREE_CODE (var) == SSA_NAME);
1201
1202   list = &(SSA_NAME_IMM_USE_NODE (var));
1203   gcc_assert (list->use == NULL);
1204
1205   if (list->prev == NULL)
1206     {
1207       gcc_assert (list->next == NULL);
1208       return false;
1209     }
1210
1211   prev = list;
1212   count = 0;
1213   for (ptr = list->next; ptr != list; )
1214     {
1215       if (prev != ptr->prev)
1216         goto error;
1217
1218       if (ptr->use == NULL)
1219         goto error; /* 2 roots, or SAFE guard node.  */
1220       else if (*(ptr->use) != var)
1221         goto error;
1222
1223       prev = ptr;
1224       ptr = ptr->next;
1225
1226       /* Avoid infinite loops.  50,000,000 uses probably indicates a
1227          problem.  */
1228       if (count++ > 50000000)
1229         goto error;
1230     }
1231
1232   /* Verify list in the other direction.  */
1233   prev = list;
1234   for (ptr = list->prev; ptr != list; )
1235     {
1236       if (prev != ptr->next)
1237         goto error;
1238       prev = ptr;
1239       ptr = ptr->prev;
1240       if (count-- < 0)
1241         goto error;
1242     }
1243
1244   if (count != 0)
1245     goto error;
1246
1247   return false;
1248
1249  error:
1250   if (ptr->loc.stmt && gimple_modified_p (ptr->loc.stmt))
1251     {
1252       fprintf (f, " STMT MODIFIED. - <%p> ", (void *)ptr->loc.stmt);
1253       print_gimple_stmt (f, ptr->loc.stmt, 0, TDF_SLIM);
1254     }
1255   fprintf (f, " IMM ERROR : (use_p : tree - %p:%p)", (void *)ptr,
1256            (void *)ptr->use);
1257   print_generic_expr (f, USE_FROM_PTR (ptr), TDF_SLIM);
1258   fprintf(f, "\n");
1259   return true;
1260 }
1261
1262
1263 /* Dump all the immediate uses to FILE.  */
1264
1265 void
1266 dump_immediate_uses_for (FILE *file, tree var)
1267 {
1268   imm_use_iterator iter;
1269   use_operand_p use_p;
1270
1271   gcc_assert (var && TREE_CODE (var) == SSA_NAME);
1272
1273   print_generic_expr (file, var, TDF_SLIM);
1274   fprintf (file, " : -->");
1275   if (has_zero_uses (var))
1276     fprintf (file, " no uses.\n");
1277   else
1278     if (has_single_use (var))
1279       fprintf (file, " single use.\n");
1280     else
1281       fprintf (file, "%d uses.\n", num_imm_uses (var));
1282
1283   FOR_EACH_IMM_USE_FAST (use_p, iter, var)
1284     {
1285       if (use_p->loc.stmt == NULL && use_p->use == NULL)
1286         fprintf (file, "***end of stmt iterator marker***\n");
1287       else
1288         if (!is_gimple_reg (USE_FROM_PTR (use_p)))
1289           print_gimple_stmt (file, USE_STMT (use_p), 0, TDF_VOPS|TDF_MEMSYMS);
1290         else
1291           print_gimple_stmt (file, USE_STMT (use_p), 0, TDF_SLIM);
1292     }
1293   fprintf(file, "\n");
1294 }
1295
1296
1297 /* Dump all the immediate uses to FILE.  */
1298
1299 void
1300 dump_immediate_uses (FILE *file)
1301 {
1302   tree var;
1303   unsigned int x;
1304
1305   fprintf (file, "Immediate_uses: \n\n");
1306   for (x = 1; x < num_ssa_names; x++)
1307     {
1308       var = ssa_name(x);
1309       if (!var)
1310         continue;
1311       dump_immediate_uses_for (file, var);
1312     }
1313 }
1314
1315
1316 /* Dump def-use edges on stderr.  */
1317
1318 DEBUG_FUNCTION void
1319 debug_immediate_uses (void)
1320 {
1321   dump_immediate_uses (stderr);
1322 }
1323
1324
1325 /* Dump def-use edges on stderr.  */
1326
1327 DEBUG_FUNCTION void
1328 debug_immediate_uses_for (tree var)
1329 {
1330   dump_immediate_uses_for (stderr, var);
1331 }
1332
1333
1334 /* Unlink STMTs virtual definition from the IL by propagating its use.  */
1335
1336 void
1337 unlink_stmt_vdef (gimple stmt)
1338 {
1339   use_operand_p use_p;
1340   imm_use_iterator iter;
1341   gimple use_stmt;
1342   tree vdef = gimple_vdef (stmt);
1343
1344   if (!vdef
1345       || TREE_CODE (vdef) != SSA_NAME)
1346     return;
1347
1348   FOR_EACH_IMM_USE_STMT (use_stmt, iter, gimple_vdef (stmt))
1349     {
1350       FOR_EACH_IMM_USE_ON_STMT (use_p, iter)
1351         SET_USE (use_p, gimple_vuse (stmt));
1352     }
1353
1354   if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (gimple_vdef (stmt)))
1355     SSA_NAME_OCCURS_IN_ABNORMAL_PHI (gimple_vuse (stmt)) = 1;
1356 }
1357