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 "diagnostic.h"
  29 #include "tree-pretty-print.h"
  30 #include "gimple-pretty-print.h"
  31 #include "tree-flow.h"
  32 #include "tree-inline.h"
  33 #include "tree-pass.h"
  34 #include "ggc.h"
  35 #include "timevar.h"
  36 #include "toplev.h"
  37 #include "langhooks.h"
  38 #include "ipa-reference.h"
  39
  40 /* This file contains the code required to manage the operands cache of the
  41    SSA optimizer.  For every stmt, we maintain an operand cache in the stmt
  42    annotation.  This cache contains operands that will be of interest to
  43    optimizers and other passes wishing to manipulate the IL.
  44
  45    The operand type are broken up into REAL and VIRTUAL operands.  The real
  46    operands are represented as pointers into the stmt's operand tree.  Thus
  47    any manipulation of the real operands will be reflected in the actual tree.
  48    Virtual operands are represented solely in the cache, although the base
  49    variable for the SSA_NAME may, or may not occur in the stmt's tree.
  50    Manipulation of the virtual operands will not be reflected in the stmt tree.
  51
  52    The routines in this file are concerned with creating this operand cache
  53    from a stmt tree.
  54
  55    The operand tree is the parsed by the various get_* routines which look
  56    through the stmt tree for the occurrence of operands which may be of
  57    interest, and calls are made to the append_* routines whenever one is
  58    found.  There are 4 of these routines, each representing one of the
  59    4 types of operands. Defs, Uses, Virtual Uses, and Virtual May Defs.
  60
  61    The append_* routines check for duplication, and simply keep a list of
  62    unique objects for each operand type in the build_* extendable vectors.
  63
  64    Once the stmt tree is completely parsed, the finalize_ssa_operands()
  65    routine is called, which proceeds to perform the finalization routine
  66    on each of the 4 operand vectors which have been built up.
  67
  68    If the stmt had a previous operand cache, the finalization routines
  69    attempt to match up the new operands with the old ones.  If it's a perfect
  70    match, the old vector is simply reused.  If it isn't a perfect match, then
  71    a new vector is created and the new operands are placed there.  For
  72    virtual operands, if the previous cache had SSA_NAME version of a
  73    variable, and that same variable occurs in the same operands cache, then
  74    the new cache vector will also get the same SSA_NAME.
  75
  76    i.e., if a stmt had a VUSE of 'a_5', and 'a' occurs in the new
  77    operand vector for VUSE, then the new vector will also be modified
  78    such that it contains 'a_5' rather than 'a'.  */
  79
  80 /* Structure storing statistics on how many call clobbers we have, and
  81    how many where avoided.  */
  82
  83 static struct
  84 {
  85   /* Number of call-clobbered ops we attempt to add to calls in
  86      add_call_clobbered_mem_symbols.  */
  87   unsigned int clobbered_vars;
  88
  89   /* Number of write-clobbers (VDEFs) avoided by using
  90      not_written information.  */
  91   unsigned int static_write_clobbers_avoided;
  92
  93   /* Number of reads (VUSEs) avoided by using not_read information.  */
  94   unsigned int static_read_clobbers_avoided;
  95
  96   /* Number of write-clobbers avoided because the variable can't escape to
  97      this call.  */
  98   unsigned int unescapable_clobbers_avoided;
  99
 100   /* Number of read-only uses we attempt to add to calls in
 101      add_call_read_mem_symbols.  */
 102   unsigned int readonly_clobbers;
 103
 104   /* Number of read-only uses we avoid using not_read information.  */
 105   unsigned int static_readonly_clobbers_avoided;
 106 } clobber_stats;
 107
 108
 109 /* Flags to describe operand properties in helpers.  */
 110
 111 /* By default, operands are loaded.  */
 112 #define opf_use         0
 113
 114 /* Operand is the target of an assignment expression or a
 115    call-clobbered variable.  */
 116 #define opf_def         (1 << 0)
 117
 118 /* No virtual operands should be created in the expression.  This is used
 119    when traversing ADDR_EXPR nodes which have different semantics than
 120    other expressions.  Inside an ADDR_EXPR node, the only operands that we
 121    need to consider are indices into arrays.  For instance, &a.b[i] should
 122    generate a USE of 'i' but it should not generate a VUSE for 'a' nor a
 123    VUSE for 'b'.  */
 124 #define opf_no_vops     (1 << 1)
 125
 126 /* Operand is an implicit reference.  This is used to distinguish
 127    explicit assignments in the form of MODIFY_EXPR from
 128    clobbering sites like function calls or ASM_EXPRs.  */
 129 #define opf_implicit    (1 << 2)
 130
 131 /* Array for building all the def operands.  */
 132 static VEC(tree,heap) *build_defs;
 133
 134 /* Array for building all the use operands.  */
 135 static VEC(tree,heap) *build_uses;
 136
 137 /* The built VDEF operand.  */
 138 static tree build_vdef;
 139
 140 /* The built VUSE operand.  */
 141 static tree build_vuse;
 142
 143 /* Bitmap obstack for our datastructures that needs to survive across
 144    compilations of multiple functions.  */
 145 static bitmap_obstack operands_bitmap_obstack;
 146
 147 static void get_expr_operands (gimple, tree *, int);
 148
 149 /* Number of functions with initialized ssa_operands.  */
 150 static int n_initialized = 0;
 151
 152 /* Return the DECL_UID of the base variable of T.  */
 153
 154 static inline unsigned
 155 get_name_decl (const_tree t)
 156 {
 157   if (TREE_CODE (t) != SSA_NAME)
 158     return DECL_UID (t);
 159   else
 160     return DECL_UID (SSA_NAME_VAR (t));
 161 }
 162
 163
 164 /*  Return true if the SSA operands cache is active.  */
 165
 166 bool
 167 ssa_operands_active (void)
 168 {
 169   /* This function may be invoked from contexts where CFUN is NULL
 170      (IPA passes), return false for now.  FIXME: operands may be
 171      active in each individual function, maybe this function should
 172      take CFUN as a parameter.  */
 173   if (cfun == NULL)
 174     return false;
 175
 176   return cfun->gimple_df && gimple_ssa_operands (cfun)->ops_active;
 177 }
 178
 179
 180 /* Create the VOP variable, an artificial global variable to act as a
 181    representative of all of the virtual operands FUD chain.  */
 182
 183 static void
 184 create_vop_var (void)
 185 {
 186   tree global_var;
 187
 188   gcc_assert (cfun->gimple_df->vop == NULL_TREE);
 189
 190   global_var = build_decl (BUILTINS_LOCATION, VAR_DECL,
 191                            get_identifier (".MEM"),
 192                            void_type_node);
 193   DECL_ARTIFICIAL (global_var) = 1;
 194   TREE_READONLY (global_var) = 0;
 195   DECL_EXTERNAL (global_var) = 1;
 196   TREE_STATIC (global_var) = 1;
 197   TREE_USED (global_var) = 1;
 198   DECL_CONTEXT (global_var) = NULL_TREE;
 199   TREE_THIS_VOLATILE (global_var) = 0;
 200   TREE_ADDRESSABLE (global_var) = 0;
 201
 202   create_var_ann (global_var);
 203   add_referenced_var (global_var);
 204   cfun->gimple_df->vop = global_var;
 205 }
 206
 207 /* These are the sizes of the operand memory buffer in bytes which gets
 208    allocated each time more operands space is required.  The final value is
 209    the amount that is allocated every time after that.
 210    In 1k we can fit 25 use operands (or 63 def operands) on a host with
 211    8 byte pointers, that would be 10 statements each with 1 def and 2
 212    uses.  */
 213
 214 #define OP_SIZE_INIT    0
 215 #define OP_SIZE_1       (1024 - sizeof (void *))
 216 #define OP_SIZE_2       (1024 * 4 - sizeof (void *))
 217 #define OP_SIZE_3       (1024 * 16 - sizeof (void *))
 218
 219 /* Initialize the operand cache routines.  */
 220
 221 void
 222 init_ssa_operands (void)
 223 {
 224   if (!n_initialized++)
 225     {
 226       build_defs = VEC_alloc (tree, heap, 5);
 227       build_uses = VEC_alloc (tree, heap, 10);
 228       build_vuse = NULL_TREE;
 229       build_vdef = NULL_TREE;
 230       bitmap_obstack_initialize (&operands_bitmap_obstack);
 231     }
 232
 233   gcc_assert (gimple_ssa_operands (cfun)->operand_memory == NULL);
 234   gimple_ssa_operands (cfun)->operand_memory_index
 235      = gimple_ssa_operands (cfun)->ssa_operand_mem_size;
 236   gimple_ssa_operands (cfun)->ops_active = true;
 237   memset (&clobber_stats, 0, sizeof (clobber_stats));
 238   gimple_ssa_operands (cfun)->ssa_operand_mem_size = OP_SIZE_INIT;
 239   create_vop_var ();
 240 }
 241
 242
 243 /* Dispose of anything required by the operand routines.  */
 244
 245 void
 246 fini_ssa_operands (void)
 247 {
 248   struct ssa_operand_memory_d *ptr;
 249
 250   if (!--n_initialized)
 251     {
 252       VEC_free (tree, heap, build_defs);
 253       VEC_free (tree, heap, build_uses);
 254       build_vdef = NULL_TREE;
 255       build_vuse = NULL_TREE;
 256     }
 257
 258   gimple_ssa_operands (cfun)->free_defs = NULL;
 259   gimple_ssa_operands (cfun)->free_uses = NULL;
 260
 261   while ((ptr = gimple_ssa_operands (cfun)->operand_memory) != NULL)
 262     {
 263       gimple_ssa_operands (cfun)->operand_memory
 264         = gimple_ssa_operands (cfun)->operand_memory->next;
 265       ggc_free (ptr);
 266     }
 267
 268   gimple_ssa_operands (cfun)->ops_active = false;
 269
 270   if (!n_initialized)
 271     bitmap_obstack_release (&operands_bitmap_obstack);
 272
 273   cfun->gimple_df->vop = NULL_TREE;
 274
 275   if (dump_file && (dump_flags & TDF_STATS))
 276     {
 277       fprintf (dump_file, "Original clobbered vars:           %d\n",
 278                clobber_stats.clobbered_vars);
 279       fprintf (dump_file, "Static write clobbers avoided:     %d\n",
 280                clobber_stats.static_write_clobbers_avoided);
 281       fprintf (dump_file, "Static read clobbers avoided:      %d\n",
 282                clobber_stats.static_read_clobbers_avoided);
 283       fprintf (dump_file, "Unescapable clobbers avoided:      %d\n",
 284                clobber_stats.unescapable_clobbers_avoided);
 285       fprintf (dump_file, "Original read-only clobbers:       %d\n",
 286                clobber_stats.readonly_clobbers);
 287       fprintf (dump_file, "Static read-only clobbers avoided: %d\n",
 288                clobber_stats.static_readonly_clobbers_avoided);
 289     }
 290 }
 291
 292
 293 /* Return memory for an operand of size SIZE.  */
 294
 295 static inline void *
 296 ssa_operand_alloc (unsigned size)
 297 {
 298   char *ptr;
 299
 300   gcc_assert (size == sizeof (struct use_optype_d)
 301               || size == sizeof (struct def_optype_d));
 302
 303   if (gimple_ssa_operands (cfun)->operand_memory_index + size
 304       >= gimple_ssa_operands (cfun)->ssa_operand_mem_size)
 305     {
 306       struct ssa_operand_memory_d *ptr;
 307
 308       switch (gimple_ssa_operands (cfun)->ssa_operand_mem_size)
 309         {
 310         case OP_SIZE_INIT:
 311           gimple_ssa_operands (cfun)->ssa_operand_mem_size = OP_SIZE_1;
 312           break;
 313         case OP_SIZE_1:
 314           gimple_ssa_operands (cfun)->ssa_operand_mem_size = OP_SIZE_2;
 315           break;
 316         case OP_SIZE_2:
 317         case OP_SIZE_3:
 318           gimple_ssa_operands (cfun)->ssa_operand_mem_size = OP_SIZE_3;
 319           break;
 320         default:
 321           gcc_unreachable ();
 322         }
 323
 324       ptr = (struct ssa_operand_memory_d *)
 325               ggc_alloc (sizeof (void *)
 326                          + gimple_ssa_operands (cfun)->ssa_operand_mem_size);
 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       {
 992         get_expr_operands (stmt, &TREE_OPERAND (expr, 0), flags);
 993         get_expr_operands (stmt, &TREE_OPERAND (expr, 1), flags);
 994         get_expr_operands (stmt, &TREE_OPERAND (expr, 2), flags);
 995         return;
 996       }
 997
 998     case FUNCTION_DECL:
 999     case LABEL_DECL:
1000     case CONST_DECL:
1001     case CASE_LABEL_EXPR:
1002       /* Expressions that make no memory references.  */
1003       return;
1004
1005     default:
1006       if (codeclass == tcc_unary)
1007         goto do_unary;
1008       if (codeclass == tcc_binary || codeclass == tcc_comparison)
1009         goto do_binary;
1010       if (codeclass == tcc_constant || codeclass == tcc_type)
1011         return;
1012     }
1013
1014   /* If we get here, something has gone wrong.  */
1015 #ifdef ENABLE_CHECKING
1016   fprintf (stderr, "unhandled expression in get_expr_operands():\n");
1017   debug_tree (expr);
1018   fputs ("\n", stderr);
1019 #endif
1020   gcc_unreachable ();
1021 }
1022
1023
1024 /* Parse STMT looking for operands.  When finished, the various
1025    build_* operand vectors will have potential operands in them.  */
1026
1027 static void
1028 parse_ssa_operands (gimple stmt)
1029 {
1030   enum gimple_code code = gimple_code (stmt);
1031
1032   if (code == GIMPLE_ASM)
1033     get_asm_expr_operands (stmt);
1034   else if (is_gimple_debug (stmt))
1035     {
1036       if (gimple_debug_bind_p (stmt)
1037           && gimple_debug_bind_has_value_p (stmt))
1038         get_expr_operands (stmt, gimple_debug_bind_get_value_ptr (stmt),
1039                            opf_use | opf_no_vops);
1040     }
1041   else
1042     {
1043       size_t i, start = 0;
1044
1045       if (code == GIMPLE_ASSIGN || code == GIMPLE_CALL)
1046         {
1047           get_expr_operands (stmt, gimple_op_ptr (stmt, 0), opf_def);
1048           start = 1;
1049         }
1050
1051       for (i = start; i < gimple_num_ops (stmt); i++)
1052         get_expr_operands (stmt, gimple_op_ptr (stmt, i), opf_use);
1053
1054       /* Add call-clobbered operands, if needed.  */
1055       if (code == GIMPLE_CALL)
1056         maybe_add_call_vops (stmt);
1057     }
1058 }
1059
1060
1061 /* Create an operands cache for STMT.  */
1062
1063 static void
1064 build_ssa_operands (gimple stmt)
1065 {
1066   /* Initially assume that the statement has no volatile operands.  */
1067   gimple_set_has_volatile_ops (stmt, false);
1068
1069   start_ssa_stmt_operands ();
1070   parse_ssa_operands (stmt);
1071   finalize_ssa_stmt_operands (stmt);
1072 }
1073
1074
1075 /* Releases the operands of STMT back to their freelists, and clears
1076    the stmt operand lists.  */
1077
1078 void
1079 free_stmt_operands (gimple stmt)
1080 {
1081   def_optype_p defs = gimple_def_ops (stmt), last_def;
1082   use_optype_p uses = gimple_use_ops (stmt), last_use;
1083
1084   if (defs)
1085     {
1086       for (last_def = defs; last_def->next; last_def = last_def->next)
1087         continue;
1088       last_def->next = gimple_ssa_operands (cfun)->free_defs;
1089       gimple_ssa_operands (cfun)->free_defs = defs;
1090       gimple_set_def_ops (stmt, NULL);
1091     }
1092
1093   if (uses)
1094     {
1095       for (last_use = uses; last_use->next; last_use = last_use->next)
1096         delink_imm_use (USE_OP_PTR (last_use));
1097       delink_imm_use (USE_OP_PTR (last_use));
1098       last_use->next = gimple_ssa_operands (cfun)->free_uses;
1099       gimple_ssa_operands (cfun)->free_uses = uses;
1100       gimple_set_use_ops (stmt, NULL);
1101     }
1102
1103   if (gimple_has_mem_ops (stmt))
1104     {
1105       gimple_set_vuse (stmt, NULL_TREE);
1106       gimple_set_vdef (stmt, NULL_TREE);
1107     }
1108 }
1109
1110
1111 /* Get the operands of statement STMT.  */
1112
1113 void
1114 update_stmt_operands (gimple stmt)
1115 {
1116   /* If update_stmt_operands is called before SSA is initialized, do
1117      nothing.  */
1118   if (!ssa_operands_active ())
1119     return;
1120
1121   timevar_push (TV_TREE_OPS);
1122
1123   gcc_assert (gimple_modified_p (stmt));
1124   build_ssa_operands (stmt);
1125   gimple_set_modified (stmt, false);
1126
1127   timevar_pop (TV_TREE_OPS);
1128 }
1129
1130
1131 /* Swap operands EXP0 and EXP1 in statement STMT.  No attempt is done
1132    to test the validity of the swap operation.  */
1133
1134 void
1135 swap_tree_operands (gimple stmt, tree *exp0, tree *exp1)
1136 {
1137   tree op0, op1;
1138   op0 = *exp0;
1139   op1 = *exp1;
1140
1141   /* If the operand cache is active, attempt to preserve the relative
1142      positions of these two operands in their respective immediate use
1143      lists.  */
1144   if (ssa_operands_active () && op0 != op1)
1145     {
1146       use_optype_p use0, use1, ptr;
1147       use0 = use1 = NULL;
1148
1149       /* Find the 2 operands in the cache, if they are there.  */
1150       for (ptr = gimple_use_ops (stmt); ptr; ptr = ptr->next)
1151         if (USE_OP_PTR (ptr)->use == exp0)
1152           {
1153             use0 = ptr;
1154             break;
1155           }
1156
1157       for (ptr = gimple_use_ops (stmt); ptr; ptr = ptr->next)
1158         if (USE_OP_PTR (ptr)->use == exp1)
1159           {
1160             use1 = ptr;
1161             break;
1162           }
1163
1164       /* If both uses don't have operand entries, there isn't much we can do
1165          at this point.  Presumably we don't need to worry about it.  */
1166       if (use0 && use1)
1167         {
1168           tree *tmp = USE_OP_PTR (use1)->use;
1169           USE_OP_PTR (use1)->use = USE_OP_PTR (use0)->use;
1170           USE_OP_PTR (use0)->use = tmp;
1171         }
1172     }
1173
1174   /* Now swap the data.  */
1175   *exp0 = op1;
1176   *exp1 = op0;
1177 }
1178
1179
1180 /* Scan the immediate_use list for VAR making sure its linked properly.
1181    Return TRUE if there is a problem and emit an error message to F.  */
1182
1183 bool
1184 verify_imm_links (FILE *f, tree var)
1185 {
1186   use_operand_p ptr, prev, list;
1187   int count;
1188
1189   gcc_assert (TREE_CODE (var) == SSA_NAME);
1190
1191   list = &(SSA_NAME_IMM_USE_NODE (var));
1192   gcc_assert (list->use == NULL);
1193
1194   if (list->prev == NULL)
1195     {
1196       gcc_assert (list->next == NULL);
1197       return false;
1198     }
1199
1200   prev = list;
1201   count = 0;
1202   for (ptr = list->next; ptr != list; )
1203     {
1204       if (prev != ptr->prev)
1205         goto error;
1206
1207       if (ptr->use == NULL)
1208         goto error; /* 2 roots, or SAFE guard node.  */
1209       else if (*(ptr->use) != var)
1210         goto error;
1211
1212       prev = ptr;
1213       ptr = ptr->next;
1214
1215       /* Avoid infinite loops.  50,000,000 uses probably indicates a
1216          problem.  */
1217       if (count++ > 50000000)
1218         goto error;
1219     }
1220
1221   /* Verify list in the other direction.  */
1222   prev = list;
1223   for (ptr = list->prev; ptr != list; )
1224     {
1225       if (prev != ptr->next)
1226         goto error;
1227       prev = ptr;
1228       ptr = ptr->prev;
1229       if (count-- < 0)
1230         goto error;
1231     }
1232
1233   if (count != 0)
1234     goto error;
1235
1236   return false;
1237
1238  error:
1239   if (ptr->loc.stmt && gimple_modified_p (ptr->loc.stmt))
1240     {
1241       fprintf (f, " STMT MODIFIED. - <%p> ", (void *)ptr->loc.stmt);
1242       print_gimple_stmt (f, ptr->loc.stmt, 0, TDF_SLIM);
1243     }
1244   fprintf (f, " IMM ERROR : (use_p : tree - %p:%p)", (void *)ptr,
1245            (void *)ptr->use);
1246   print_generic_expr (f, USE_FROM_PTR (ptr), TDF_SLIM);
1247   fprintf(f, "\n");
1248   return true;
1249 }
1250
1251
1252 /* Dump all the immediate uses to FILE.  */
1253
1254 void
1255 dump_immediate_uses_for (FILE *file, tree var)
1256 {
1257   imm_use_iterator iter;
1258   use_operand_p use_p;
1259
1260   gcc_assert (var && TREE_CODE (var) == SSA_NAME);
1261
1262   print_generic_expr (file, var, TDF_SLIM);
1263   fprintf (file, " : -->");
1264   if (has_zero_uses (var))
1265     fprintf (file, " no uses.\n");
1266   else
1267     if (has_single_use (var))
1268       fprintf (file, " single use.\n");
1269     else
1270       fprintf (file, "%d uses.\n", num_imm_uses (var));
1271
1272   FOR_EACH_IMM_USE_FAST (use_p, iter, var)
1273     {
1274       if (use_p->loc.stmt == NULL && use_p->use == NULL)
1275         fprintf (file, "***end of stmt iterator marker***\n");
1276       else
1277         if (!is_gimple_reg (USE_FROM_PTR (use_p)))
1278           print_gimple_stmt (file, USE_STMT (use_p), 0, TDF_VOPS|TDF_MEMSYMS);
1279         else
1280           print_gimple_stmt (file, USE_STMT (use_p), 0, TDF_SLIM);
1281     }
1282   fprintf(file, "\n");
1283 }
1284
1285
1286 /* Dump all the immediate uses to FILE.  */
1287
1288 void
1289 dump_immediate_uses (FILE *file)
1290 {
1291   tree var;
1292   unsigned int x;
1293
1294   fprintf (file, "Immediate_uses: \n\n");
1295   for (x = 1; x < num_ssa_names; x++)
1296     {
1297       var = ssa_name(x);
1298       if (!var)
1299         continue;
1300       dump_immediate_uses_for (file, var);
1301     }
1302 }
1303
1304
1305 /* Dump def-use edges on stderr.  */
1306
1307 void
1308 debug_immediate_uses (void)
1309 {
1310   dump_immediate_uses (stderr);
1311 }
1312
1313
1314 /* Dump def-use edges on stderr.  */
1315
1316 void
1317 debug_immediate_uses_for (tree var)
1318 {
1319   dump_immediate_uses_for (stderr, var);
1320 }
1321
1322
1323 /* Unlink STMTs virtual definition from the IL by propagating its use.  */
1324
1325 void
1326 unlink_stmt_vdef (gimple stmt)
1327 {
1328   use_operand_p use_p;
1329   imm_use_iterator iter;
1330   gimple use_stmt;
1331   tree vdef = gimple_vdef (stmt);
1332
1333   if (!vdef
1334       || TREE_CODE (vdef) != SSA_NAME)
1335     return;
1336
1337   FOR_EACH_IMM_USE_STMT (use_stmt, iter, gimple_vdef (stmt))
1338     {
1339       FOR_EACH_IMM_USE_ON_STMT (use_p, iter)
1340         SET_USE (use_p, gimple_vuse (stmt));
1341     }
1342
1343   if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (gimple_vdef (stmt)))
1344     SSA_NAME_OCCURS_IN_ABNORMAL_PHI (gimple_vuse (stmt)) = 1;
1345 }
1346