gcc/tree-ssa-operands.cc

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