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