gcc/tree-dfa.c

   1 /* Data flow functions for trees.
   2    Copyright (C) 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
   3    Contributed by Diego Novillo <dnovillo@redhat.com>
   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 2, 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 COPYING.  If not, write to
  19 the Free Software Foundation, 51 Franklin Street, Fifth Floor,
  20 Boston, MA 02110-1301, USA.  */
  21
  22 #include "config.h"
  23 #include "system.h"
  24 #include "coretypes.h"
  25 #include "tm.h"
  26 #include "hashtab.h"
  27 #include "pointer-set.h"
  28 #include "tree.h"
  29 #include "rtl.h"
  30 #include "tm_p.h"
  31 #include "hard-reg-set.h"
  32 #include "basic-block.h"
  33 #include "output.h"
  34 #include "timevar.h"
  35 #include "expr.h"
  36 #include "ggc.h"
  37 #include "langhooks.h"
  38 #include "flags.h"
  39 #include "function.h"
  40 #include "diagnostic.h"
  41 #include "tree-dump.h"
  42 #include "tree-gimple.h"
  43 #include "tree-flow.h"
  44 #include "tree-inline.h"
  45 #include "tree-pass.h"
  46 #include "convert.h"
  47 #include "params.h"
  48 #include "cgraph.h"
  49
  50 /* Build and maintain data flow information for trees.  */
  51
  52 /* Counters used to display DFA and SSA statistics.  */
  53 struct dfa_stats_d
  54 {
  55   long num_stmt_anns;
  56   long num_var_anns;
  57   long num_defs;
  58   long num_uses;
  59   long num_phis;
  60   long num_phi_args;
  61   int max_num_phi_args;
  62   long num_v_may_defs;
  63   long num_vuses;
  64   long num_v_must_defs;
  65 };
  66
  67
  68 /* State information for find_vars_r.  */
  69 struct walk_state
  70 {
  71   /* Hash table used to avoid adding the same variable more than once.  */
  72   htab_t vars_found;
  73 };
  74
  75
  76 /* Local functions.  */
  77 static void collect_dfa_stats (struct dfa_stats_d *);
  78 static tree collect_dfa_stats_r (tree *, int *, void *);
  79 static tree find_vars_r (tree *, int *, void *);
  80 static void add_referenced_var (tree, struct walk_state *);
  81
  82
  83 /* Global declarations.  */
  84
  85 /* Array of all variables referenced in the function.  */
  86 htab_t referenced_vars;
  87
  88
  89 /*---------------------------------------------------------------------------
  90                         Dataflow analysis (DFA) routines
  91 ---------------------------------------------------------------------------*/
  92 /* Find all the variables referenced in the function.  This function
  93    builds the global arrays REFERENCED_VARS and CALL_CLOBBERED_VARS.
  94
  95    Note that this function does not look for statement operands, it simply
  96    determines what variables are referenced in the program and detects
  97    various attributes for each variable used by alias analysis and the
  98    optimizer.  */
  99
 100 static void
 101 find_referenced_vars (void)
 102 {
 103   htab_t vars_found;
 104   basic_block bb;
 105   block_stmt_iterator si;
 106   struct walk_state walk_state;
 107
 108   vars_found = htab_create (50, htab_hash_pointer, htab_eq_pointer, NULL);
 109   memset (&walk_state, 0, sizeof (walk_state));
 110   walk_state.vars_found = vars_found;
 111
 112   FOR_EACH_BB (bb)
 113     for (si = bsi_start (bb); !bsi_end_p (si); bsi_next (&si))
 114       {
 115         tree *stmt_p = bsi_stmt_ptr (si);
 116         walk_tree (stmt_p, find_vars_r, &walk_state, NULL);
 117       }
 118
 119   htab_delete (vars_found);
 120 }
 121
 122 struct tree_opt_pass pass_referenced_vars =
 123 {
 124   NULL,                                 /* name */
 125   NULL,                                 /* gate */
 126   find_referenced_vars,                 /* execute */
 127   NULL,                                 /* sub */
 128   NULL,                                 /* next */
 129   0,                                    /* static_pass_number */
 130   TV_FIND_REFERENCED_VARS,              /* tv_id */
 131   PROP_gimple_leh | PROP_cfg,           /* properties_required */
 132   PROP_referenced_vars,                 /* properties_provided */
 133   0,                                    /* properties_destroyed */
 134   0,                                    /* todo_flags_start */
 135   0,                                    /* todo_flags_finish */
 136   0                                     /* letter */
 137 };
 138
 139
 140 /*---------------------------------------------------------------------------
 141                             Manage annotations
 142 ---------------------------------------------------------------------------*/
 143 /* Create a new annotation for a _DECL node T.  */
 144
 145 var_ann_t
 146 create_var_ann (tree t)
 147 {
 148   var_ann_t ann;
 149
 150   gcc_assert (t);
 151   gcc_assert (DECL_P (t));
 152   gcc_assert (!t->common.ann || t->common.ann->common.type == VAR_ANN);
 153
 154   ann = ggc_alloc (sizeof (*ann));
 155   memset ((void *) ann, 0, sizeof (*ann));
 156
 157   ann->common.type = VAR_ANN;
 158
 159   t->common.ann = (tree_ann_t) ann;
 160
 161   return ann;
 162 }
 163
 164
 165 /* Create a new annotation for a statement node T.  */
 166
 167 stmt_ann_t
 168 create_stmt_ann (tree t)
 169 {
 170   stmt_ann_t ann;
 171
 172   gcc_assert (is_gimple_stmt (t));
 173   gcc_assert (!t->common.ann || t->common.ann->common.type == STMT_ANN);
 174
 175   ann = ggc_alloc (sizeof (*ann));
 176   memset ((void *) ann, 0, sizeof (*ann));
 177
 178   ann->common.type = STMT_ANN;
 179
 180   /* Since we just created the annotation, mark the statement modified.  */
 181   ann->modified = true;
 182
 183   t->common.ann = (tree_ann_t) ann;
 184
 185   return ann;
 186 }
 187
 188 /* Create a new annotation for a tree T.  */
 189
 190 tree_ann_t
 191 create_tree_ann (tree t)
 192 {
 193   tree_ann_t ann;
 194
 195   gcc_assert (t);
 196   gcc_assert (!t->common.ann || t->common.ann->common.type == TREE_ANN_COMMON);
 197
 198   ann = ggc_alloc (sizeof (*ann));
 199   memset ((void *) ann, 0, sizeof (*ann));
 200
 201   ann->common.type = TREE_ANN_COMMON;
 202   t->common.ann = ann;
 203
 204   return ann;
 205 }
 206
 207 /* Build a temporary.  Make sure and register it to be renamed.  */
 208
 209 tree
 210 make_rename_temp (tree type, const char *prefix)
 211 {
 212   tree t = create_tmp_var (type, prefix);
 213   if (referenced_vars)
 214     {
 215       add_referenced_tmp_var (t);
 216       mark_sym_for_renaming (t);
 217     }
 218
 219   return t;
 220 }
 221
 222
 223
 224 /*---------------------------------------------------------------------------
 225                               Debugging functions
 226 ---------------------------------------------------------------------------*/
 227 /* Dump the list of all the referenced variables in the current function to
 228    FILE.  */
 229
 230 void
 231 dump_referenced_vars (FILE *file)
 232 {
 233   tree var;
 234   referenced_var_iterator rvi;
 235
 236   fprintf (file, "\nReferenced variables in %s: %u\n\n",
 237            get_name (current_function_decl), (unsigned) num_referenced_vars);
 238
 239   FOR_EACH_REFERENCED_VAR (var, rvi)
 240     {
 241       fprintf (file, "Variable: ");
 242       dump_variable (file, var);
 243       fprintf (file, "\n");
 244     }
 245 }
 246
 247
 248 /* Dump the list of all the referenced variables to stderr.  */
 249
 250 void
 251 debug_referenced_vars (void)
 252 {
 253   dump_referenced_vars (stderr);
 254 }
 255
 256
 257 /* Dump sub-variables for VAR to FILE.  */
 258
 259 void
 260 dump_subvars_for (FILE *file, tree var)
 261 {
 262   subvar_t sv = get_subvars_for_var (var);
 263
 264   if (!sv)
 265     return;
 266
 267   fprintf (file, "{ ");
 268
 269   for (; sv; sv = sv->next)
 270     {
 271       print_generic_expr (file, sv->var, dump_flags);
 272       fprintf (file, " ");
 273     }
 274
 275   fprintf (file, "}");
 276 }
 277
 278
 279 /* Dumb sub-variables for VAR to stderr.  */
 280
 281 void
 282 debug_subvars_for (tree var)
 283 {
 284   dump_subvars_for (stderr, var);
 285 }
 286
 287
 288 /* Dump variable VAR and its may-aliases to FILE.  */
 289
 290 void
 291 dump_variable (FILE *file, tree var)
 292 {
 293   var_ann_t ann;
 294
 295   if (TREE_CODE (var) == SSA_NAME)
 296     {
 297       if (POINTER_TYPE_P (TREE_TYPE (var)))
 298         dump_points_to_info_for (file, var);
 299       var = SSA_NAME_VAR (var);
 300     }
 301
 302   if (var == NULL_TREE)
 303     {
 304       fprintf (file, "<nil>");
 305       return;
 306     }
 307
 308   print_generic_expr (file, var, dump_flags);
 309
 310   ann = var_ann (var);
 311
 312   fprintf (file, ", UID %u", (unsigned) DECL_UID (var));
 313
 314   fprintf (file, ", ");
 315   print_generic_expr (file, TREE_TYPE (var), dump_flags);
 316
 317   if (ann && ann->type_mem_tag)
 318     {
 319       fprintf (file, ", type memory tag: ");
 320       print_generic_expr (file, ann->type_mem_tag, dump_flags);
 321     }
 322
 323   if (ann && ann->is_alias_tag)
 324     fprintf (file, ", is an alias tag");
 325
 326   if (TREE_ADDRESSABLE (var))
 327     fprintf (file, ", is addressable");
 328
 329   if (is_global_var (var))
 330     fprintf (file, ", is global");
 331
 332   if (TREE_THIS_VOLATILE (var))
 333     fprintf (file, ", is volatile");
 334
 335   if (is_call_clobbered (var))
 336     fprintf (file, ", call clobbered");
 337
 338   if (default_def (var))
 339     {
 340       fprintf (file, ", default def: ");
 341       print_generic_expr (file, default_def (var), dump_flags);
 342     }
 343
 344   if (may_aliases (var))
 345     {
 346       fprintf (file, ", may aliases: ");
 347       dump_may_aliases_for (file, var);
 348     }
 349
 350   if (get_subvars_for_var (var))
 351     {
 352       fprintf (file, ", sub-vars: ");
 353       dump_subvars_for (file, var);
 354     }
 355
 356   fprintf (file, "\n");
 357 }
 358
 359
 360 /* Dump variable VAR and its may-aliases to stderr.  */
 361
 362 void
 363 debug_variable (tree var)
 364 {
 365   dump_variable (stderr, var);
 366 }
 367
 368
 369 /* Dump various DFA statistics to FILE.  */
 370
 371 void
 372 dump_dfa_stats (FILE *file)
 373 {
 374   struct dfa_stats_d dfa_stats;
 375
 376   unsigned long size, total = 0;
 377   const char * const fmt_str   = "%-30s%-13s%12s\n";
 378   const char * const fmt_str_1 = "%-30s%13lu%11lu%c\n";
 379   const char * const fmt_str_3 = "%-43s%11lu%c\n";
 380   const char *funcname
 381     = lang_hooks.decl_printable_name (current_function_decl, 2);
 382
 383   collect_dfa_stats (&dfa_stats);
 384
 385   fprintf (file, "\nDFA Statistics for %s\n\n", funcname);
 386
 387   fprintf (file, "---------------------------------------------------------\n");
 388   fprintf (file, fmt_str, "", "  Number of  ", "Memory");
 389   fprintf (file, fmt_str, "", "  instances  ", "used ");
 390   fprintf (file, "---------------------------------------------------------\n");
 391
 392   size = num_referenced_vars * sizeof (tree);
 393   total += size;
 394   fprintf (file, fmt_str_1, "Referenced variables", (unsigned long)num_referenced_vars,
 395            SCALE (size), LABEL (size));
 396
 397   size = dfa_stats.num_stmt_anns * sizeof (struct stmt_ann_d);
 398   total += size;
 399   fprintf (file, fmt_str_1, "Statements annotated", dfa_stats.num_stmt_anns,
 400            SCALE (size), LABEL (size));
 401
 402   size = dfa_stats.num_var_anns * sizeof (struct var_ann_d);
 403   total += size;
 404   fprintf (file, fmt_str_1, "Variables annotated", dfa_stats.num_var_anns,
 405            SCALE (size), LABEL (size));
 406
 407   size = dfa_stats.num_uses * sizeof (tree *);
 408   total += size;
 409   fprintf (file, fmt_str_1, "USE operands", dfa_stats.num_uses,
 410            SCALE (size), LABEL (size));
 411
 412   size = dfa_stats.num_defs * sizeof (tree *);
 413   total += size;
 414   fprintf (file, fmt_str_1, "DEF operands", dfa_stats.num_defs,
 415            SCALE (size), LABEL (size));
 416
 417   size = dfa_stats.num_vuses * sizeof (tree *);
 418   total += size;
 419   fprintf (file, fmt_str_1, "VUSE operands", dfa_stats.num_vuses,
 420            SCALE (size), LABEL (size));
 421
 422   size = dfa_stats.num_v_may_defs * sizeof (tree *);
 423   total += size;
 424   fprintf (file, fmt_str_1, "V_MAY_DEF operands", dfa_stats.num_v_may_defs,
 425            SCALE (size), LABEL (size));
 426
 427   size = dfa_stats.num_v_must_defs * sizeof (tree *);
 428   total += size;
 429   fprintf (file, fmt_str_1, "V_MUST_DEF operands", dfa_stats.num_v_must_defs,
 430            SCALE (size), LABEL (size));
 431
 432   size = dfa_stats.num_phis * sizeof (struct tree_phi_node);
 433   total += size;
 434   fprintf (file, fmt_str_1, "PHI nodes", dfa_stats.num_phis,
 435            SCALE (size), LABEL (size));
 436
 437   size = dfa_stats.num_phi_args * sizeof (struct phi_arg_d);
 438   total += size;
 439   fprintf (file, fmt_str_1, "PHI arguments", dfa_stats.num_phi_args,
 440            SCALE (size), LABEL (size));
 441
 442   fprintf (file, "---------------------------------------------------------\n");
 443   fprintf (file, fmt_str_3, "Total memory used by DFA/SSA data", SCALE (total),
 444            LABEL (total));
 445   fprintf (file, "---------------------------------------------------------\n");
 446   fprintf (file, "\n");
 447
 448   if (dfa_stats.num_phis)
 449     fprintf (file, "Average number of arguments per PHI node: %.1f (max: %d)\n",
 450              (float) dfa_stats.num_phi_args / (float) dfa_stats.num_phis,
 451              dfa_stats.max_num_phi_args);
 452
 453   fprintf (file, "\n");
 454 }
 455
 456
 457 /* Dump DFA statistics on stderr.  */
 458
 459 void
 460 debug_dfa_stats (void)
 461 {
 462   dump_dfa_stats (stderr);
 463 }
 464
 465
 466 /* Collect DFA statistics and store them in the structure pointed to by
 467    DFA_STATS_P.  */
 468
 469 static void
 470 collect_dfa_stats (struct dfa_stats_d *dfa_stats_p)
 471 {
 472   struct pointer_set_t *pset;
 473   basic_block bb;
 474   block_stmt_iterator i;
 475
 476   gcc_assert (dfa_stats_p);
 477
 478   memset ((void *)dfa_stats_p, 0, sizeof (struct dfa_stats_d));
 479
 480   /* Walk all the trees in the function counting references.  Start at
 481      basic block 0, but don't stop at block boundaries.  */
 482   pset = pointer_set_create ();
 483
 484   for (i = bsi_start (BASIC_BLOCK (0)); !bsi_end_p (i); bsi_next (&i))
 485     walk_tree (bsi_stmt_ptr (i), collect_dfa_stats_r, (void *) dfa_stats_p,
 486                pset);
 487
 488   pointer_set_destroy (pset);
 489
 490   FOR_EACH_BB (bb)
 491     {
 492       tree phi;
 493       for (phi = phi_nodes (bb); phi; phi = PHI_CHAIN (phi))
 494         {
 495           dfa_stats_p->num_phis++;
 496           dfa_stats_p->num_phi_args += PHI_NUM_ARGS (phi);
 497           if (PHI_NUM_ARGS (phi) > dfa_stats_p->max_num_phi_args)
 498             dfa_stats_p->max_num_phi_args = PHI_NUM_ARGS (phi);
 499         }
 500     }
 501 }
 502
 503
 504 /* Callback for walk_tree to collect DFA statistics for a tree and its
 505    children.  */
 506
 507 static tree
 508 collect_dfa_stats_r (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED,
 509                      void *data)
 510 {
 511   tree t = *tp;
 512   struct dfa_stats_d *dfa_stats_p = (struct dfa_stats_d *)data;
 513
 514   if (t->common.ann)
 515     {
 516       switch (ann_type (t->common.ann))
 517         {
 518         case STMT_ANN:
 519           {
 520             dfa_stats_p->num_stmt_anns++;
 521             dfa_stats_p->num_defs += NUM_SSA_OPERANDS (t, SSA_OP_DEF);
 522             dfa_stats_p->num_uses += NUM_SSA_OPERANDS (t, SSA_OP_USE);
 523             dfa_stats_p->num_v_may_defs += NUM_SSA_OPERANDS (t, SSA_OP_VMAYDEF);
 524             dfa_stats_p->num_vuses += NUM_SSA_OPERANDS (t, SSA_OP_VUSE);
 525             dfa_stats_p->num_v_must_defs +=
 526                                   NUM_SSA_OPERANDS (t, SSA_OP_VMUSTDEF);
 527             break;
 528           }
 529
 530         case VAR_ANN:
 531           dfa_stats_p->num_var_anns++;
 532           break;
 533
 534         default:
 535           break;
 536         }
 537     }
 538
 539   return NULL;
 540 }
 541
 542
 543 /*---------------------------------------------------------------------------
 544                              Miscellaneous helpers
 545 ---------------------------------------------------------------------------*/
 546 /* Callback for walk_tree.  Used to collect variables referenced in
 547    the function.  */
 548
 549 static tree
 550 find_vars_r (tree *tp, int *walk_subtrees, void *data)
 551 {
 552   struct walk_state *walk_state = (struct walk_state *) data;
 553
 554   /* If T is a regular variable that the optimizers are interested
 555      in, add it to the list of variables.  */
 556   if (SSA_VAR_P (*tp))
 557     add_referenced_var (*tp, walk_state);
 558
 559   /* Type, _DECL and constant nodes have no interesting children.
 560      Ignore them.  */
 561   else if (IS_TYPE_OR_DECL_P (*tp) || CONSTANT_CLASS_P (*tp))
 562     *walk_subtrees = 0;
 563
 564   return NULL_TREE;
 565 }
 566
 567
 568 /* Lookup UID in the referenced_vars hashtable and return the associated
 569    variable or NULL if it is not there.  */
 570
 571 tree
 572 referenced_var_lookup_if_exists (unsigned int uid)
 573 {
 574   struct int_tree_map *h, in;
 575   in.uid = uid;
 576   h = htab_find_with_hash (referenced_vars, &in, uid);
 577   if (h)
 578     return h->to;
 579   return NULL_TREE;
 580 }
 581
 582 /* Lookup UID in the referenced_vars hashtable and return the associated
 583    variable.  */
 584
 585 tree
 586 referenced_var_lookup (unsigned int uid)
 587 {
 588   struct int_tree_map *h, in;
 589   in.uid = uid;
 590   h = htab_find_with_hash (referenced_vars, &in, uid);
 591   gcc_assert (h || uid == 0);
 592   if (h)
 593     return h->to;
 594   return NULL_TREE;
 595 }
 596
 597 /* Insert the pair UID, TO into the referenced_vars hashtable.  */
 598
 599 static void
 600 referenced_var_insert (unsigned int uid, tree to)
 601 {
 602   struct int_tree_map *h;
 603   void **loc;
 604
 605   h = ggc_alloc (sizeof (struct int_tree_map));
 606   h->uid = uid;
 607   h->to = to;
 608   loc = htab_find_slot_with_hash (referenced_vars, h, uid, INSERT);
 609   *(struct int_tree_map **)  loc = h;
 610 }
 611
 612 /* Add VAR to the list of dereferenced variables.
 613
 614    WALK_STATE contains a hash table used to avoid adding the same
 615       variable more than once. Note that this function assumes that
 616       VAR is a valid SSA variable.  If WALK_STATE is NULL, no
 617       duplicate checking is done.  */
 618
 619 static void
 620 add_referenced_var (tree var, struct walk_state *walk_state)
 621 {
 622   void **slot;
 623   var_ann_t v_ann;
 624
 625   v_ann = get_var_ann (var);
 626
 627   if (walk_state)
 628     slot = htab_find_slot (walk_state->vars_found, (void *) var, INSERT);
 629   else
 630     slot = NULL;
 631
 632   if (slot == NULL || *slot == NULL)
 633     {
 634       /* This is the first time we find this variable, add it to the
 635          REFERENCED_VARS array and annotate it with attributes that are
 636          intrinsic to the variable.  */
 637       if (slot)
 638         *slot = (void *) var;
 639
 640       referenced_var_insert (DECL_UID (var), var);
 641
 642       /* Tag's don't have DECL_INITIAL.  */
 643       if (MTAG_P (var))
 644         return;
 645
 646       /* Scan DECL_INITIAL for pointer variables as they may contain
 647          address arithmetic referencing the address of other
 648          variables.  */
 649       if (DECL_INITIAL (var)
 650           /* Initializers of external variables are not useful to the
 651              optimizers.  */
 652           && !DECL_EXTERNAL (var)
 653           /* It's not necessary to walk the initial value of non-constant
 654              public variables because it cannot be propagated by the
 655              optimizers.  */
 656           && (!TREE_PUBLIC (var) || !TREE_CONSTANT (var)))
 657         walk_tree (&DECL_INITIAL (var), find_vars_r, walk_state, 0);
 658     }
 659 }
 660
 661
 662 /* Return the virtual variable associated to the non-scalar variable VAR.  */
 663
 664 tree
 665 get_virtual_var (tree var)
 666 {
 667   STRIP_NOPS (var);
 668
 669   if (TREE_CODE (var) == SSA_NAME)
 670     var = SSA_NAME_VAR (var);
 671
 672   while (TREE_CODE (var) == REALPART_EXPR || TREE_CODE (var) == IMAGPART_EXPR
 673          || handled_component_p (var))
 674     var = TREE_OPERAND (var, 0);
 675
 676   /* Treating GIMPLE registers as virtual variables makes no sense.
 677      Also complain if we couldn't extract a _DECL out of the original
 678      expression.  */
 679   gcc_assert (SSA_VAR_P (var));
 680   gcc_assert (!is_gimple_reg (var));
 681
 682   return var;
 683 }
 684
 685 /* Add a temporary variable to REFERENCED_VARS.  This is similar to
 686    add_referenced_var, but is used by passes that need to add new temps to
 687    the REFERENCED_VARS array after the program has been scanned for
 688    variables.  The variable will just receive a new UID and be added
 689    to the REFERENCED_VARS array without checking for duplicates.  */
 690
 691 void
 692 add_referenced_tmp_var (tree var)
 693 {
 694   add_referenced_var (var, NULL);
 695 }
 696
 697
 698 /* Mark all the non-SSA variables found in STMT's operands to be
 699    processed by update_ssa.  */
 700
 701 void
 702 mark_new_vars_to_rename (tree stmt)
 703 {
 704   ssa_op_iter iter;
 705   tree val;
 706   bitmap vars_in_vops_to_rename;
 707   bool found_exposed_symbol = false;
 708   int v_may_defs_before, v_may_defs_after;
 709   int v_must_defs_before, v_must_defs_after;
 710
 711   if (TREE_CODE (stmt) == PHI_NODE)
 712     return;
 713
 714   vars_in_vops_to_rename = BITMAP_ALLOC (NULL);
 715
 716   /* Before re-scanning the statement for operands, mark the existing
 717      virtual operands to be renamed again.  We do this because when new
 718      symbols are exposed, the virtual operands that were here before due to
 719      aliasing will probably be removed by the call to get_stmt_operand.
 720      Therefore, we need to flag them to be renamed beforehand.
 721
 722      We flag them in a separate bitmap because we don't really want to
 723      rename them if there are not any newly exposed symbols in the
 724      statement operands.  */
 725   v_may_defs_before = NUM_SSA_OPERANDS (stmt, SSA_OP_VMAYDEF);
 726   v_must_defs_before = NUM_SSA_OPERANDS (stmt, SSA_OP_VMUSTDEF);
 727
 728   FOR_EACH_SSA_TREE_OPERAND (val, stmt, iter,
 729                              SSA_OP_VMAYDEF | SSA_OP_VUSE | SSA_OP_VMUSTDEF)
 730     {
 731       if (!DECL_P (val))
 732         val = SSA_NAME_VAR (val);
 733       bitmap_set_bit (vars_in_vops_to_rename, DECL_UID (val));
 734     }
 735
 736   /* Now force an operand re-scan on the statement and mark any newly
 737      exposed variables.  */
 738   update_stmt (stmt);
 739
 740   v_may_defs_after = NUM_SSA_OPERANDS (stmt, SSA_OP_VMAYDEF);
 741   v_must_defs_after = NUM_SSA_OPERANDS (stmt, SSA_OP_VMUSTDEF);
 742
 743   FOR_EACH_SSA_TREE_OPERAND (val, stmt, iter, SSA_OP_ALL_OPERANDS)
 744     if (DECL_P (val))
 745       {
 746         found_exposed_symbol = true;
 747         mark_sym_for_renaming (val);
 748       }
 749
 750   /* If we found any newly exposed symbols, or if there are fewer VDEF
 751      operands in the statement, add the variables we had set in
 752      VARS_IN_VOPS_TO_RENAME to VARS_TO_RENAME.  We need to check for
 753      vanishing VDEFs because in those cases, the names that were formerly
 754      generated by this statement are not going to be available anymore.  */
 755   if (found_exposed_symbol
 756       || v_may_defs_before > v_may_defs_after
 757       || v_must_defs_before > v_must_defs_after)
 758     mark_set_for_renaming (vars_in_vops_to_rename);
 759
 760   BITMAP_FREE (vars_in_vops_to_rename);
 761 }
 762
 763 /* Find all variables within the gimplified statement that were not previously
 764    visible to the function and add them to the referenced variables list.  */
 765
 766 static tree
 767 find_new_referenced_vars_1 (tree *tp, int *walk_subtrees,
 768                             void *data ATTRIBUTE_UNUSED)
 769 {
 770   tree t = *tp;
 771
 772   if (TREE_CODE (t) == VAR_DECL && !var_ann (t))
 773     {
 774       add_referenced_tmp_var (t);
 775       mark_sym_for_renaming (t);
 776     }
 777
 778   if (IS_TYPE_OR_DECL_P (t))
 779     *walk_subtrees = 0;
 780
 781   return NULL;
 782 }
 783
 784 void
 785 find_new_referenced_vars (tree *stmt_p)
 786 {
 787   walk_tree (stmt_p, find_new_referenced_vars_1, NULL, NULL);
 788 }
 789
 790
 791 /* If REF is a COMPONENT_REF for a structure that can have sub-variables, and
 792    we know where REF is accessing, return the variable in REF that has the
 793    sub-variables.  If the return value is not NULL, POFFSET will be the
 794    offset, in bits, of REF inside the return value, and PSIZE will be the
 795    size, in bits, of REF inside the return value.  */
 796
 797 tree
 798 okay_component_ref_for_subvars (tree ref, unsigned HOST_WIDE_INT *poffset,
 799                                 unsigned HOST_WIDE_INT *psize)
 800 {
 801   tree result = NULL;
 802   HOST_WIDE_INT bitsize;
 803   HOST_WIDE_INT bitpos;
 804   tree offset;
 805   enum machine_mode mode;
 806   int unsignedp;
 807   int volatilep;
 808
 809   gcc_assert (!SSA_VAR_P (ref));
 810   *poffset = 0;
 811   *psize = (unsigned int) -1;
 812
 813   ref = get_inner_reference (ref, &bitsize, &bitpos, &offset, &mode,
 814                              &unsignedp, &volatilep, false);
 815   if (TREE_CODE (ref) == INDIRECT_REF)
 816     return result;
 817   else if (offset == NULL && bitsize != -1 && SSA_VAR_P (ref))
 818     {
 819       *poffset = bitpos;
 820       *psize = bitsize;
 821       if (get_subvars_for_var (ref) != NULL)
 822         return ref;
 823     }
 824   else if (SSA_VAR_P (ref))
 825     {
 826       if (get_subvars_for_var (ref) != NULL)
 827         return ref;
 828     }
 829   return NULL_TREE;
 830 }