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