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, 59 Temple Place - Suite 330,
  20 Boston, MA 02111-1307, 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 VEC(tree,gc) *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
 189 /* Create a new annotation for a tree T.  */
 190
 191 tree_ann_t
 192 create_tree_ann (tree t)
 193 {
 194   tree_ann_t ann;
 195
 196   gcc_assert (t);
 197   gcc_assert (!t->common.ann || t->common.ann->common.type == TREE_ANN_COMMON);
 198
 199   ann = ggc_alloc (sizeof (*ann));
 200   memset ((void *) ann, 0, sizeof (*ann));
 201
 202   ann->common.type = TREE_ANN_COMMON;
 203   t->common.ann = ann;
 204
 205   return ann;
 206 }
 207
 208 /* Build a temporary.  Make sure and register it to be renamed.  */
 209
 210 tree
 211 make_rename_temp (tree type, const char *prefix)
 212 {
 213   tree t = create_tmp_var (type, prefix);
 214   if (referenced_vars)
 215     {
 216       add_referenced_tmp_var (t);
 217       mark_sym_for_renaming (t);
 218     }
 219
 220   return t;
 221 }
 222
 223
 224
 225 /*---------------------------------------------------------------------------
 226                               Debugging functions
 227 ---------------------------------------------------------------------------*/
 228 /* Dump the list of all the referenced variables in the current function to
 229    FILE.  */
 230
 231 void
 232 dump_referenced_vars (FILE *file)
 233 {
 234   size_t i;
 235
 236   fprintf (file, "\nReferenced variables in %s: %u\n\n",
 237            get_name (current_function_decl), (unsigned) num_referenced_vars);
 238
 239   for (i = 0; i < num_referenced_vars; i++)
 240     {
 241       tree var = referenced_var (i);
 242       fprintf (file, "Variable: ");
 243       dump_variable (file, var);
 244       fprintf (file, "\n");
 245     }
 246 }
 247
 248
 249 /* Dump the list of all the referenced variables to stderr.  */
 250
 251 void
 252 debug_referenced_vars (void)
 253 {
 254   dump_referenced_vars (stderr);
 255 }
 256
 257
 258 /* Dump variable VAR and its may-aliases to FILE.  */
 259
 260 void
 261 dump_variable (FILE *file, tree var)
 262 {
 263   var_ann_t ann;
 264
 265   if (TREE_CODE (var) == SSA_NAME)
 266     {
 267       if (POINTER_TYPE_P (TREE_TYPE (var)))
 268         dump_points_to_info_for (file, var);
 269       var = SSA_NAME_VAR (var);
 270     }
 271
 272   if (var == NULL_TREE)
 273     {
 274       fprintf (file, "<nil>");
 275       return;
 276     }
 277
 278   print_generic_expr (file, var, dump_flags);
 279
 280   ann = var_ann (var);
 281
 282   fprintf (file, ", UID %u", (unsigned) ann->uid);
 283
 284   fprintf (file, ", ");
 285   print_generic_expr (file, TREE_TYPE (var), dump_flags);
 286
 287   if (ann->type_mem_tag)
 288     {
 289       fprintf (file, ", type memory tag: ");
 290       print_generic_expr (file, ann->type_mem_tag, dump_flags);
 291     }
 292
 293   if (ann->is_alias_tag)
 294     fprintf (file, ", is an alias tag");
 295
 296   if (TREE_ADDRESSABLE (var))
 297     fprintf (file, ", is addressable");
 298
 299   if (is_global_var (var))
 300     fprintf (file, ", is global");
 301
 302   if (TREE_THIS_VOLATILE (var))
 303     fprintf (file, ", is volatile");
 304
 305   if (is_call_clobbered (var))
 306     fprintf (file, ", call clobbered");
 307
 308   if (ann->default_def)
 309     {
 310       fprintf (file, ", default def: ");
 311       print_generic_expr (file, ann->default_def, dump_flags);
 312     }
 313
 314   if (ann->may_aliases)
 315     {
 316       fprintf (file, ", may aliases: ");
 317       dump_may_aliases_for (file, var);
 318     }
 319
 320   fprintf (file, "\n");
 321 }
 322
 323
 324 /* Dump variable VAR and its may-aliases to stderr.  */
 325
 326 void
 327 debug_variable (tree var)
 328 {
 329   dump_variable (stderr, var);
 330 }
 331
 332
 333 /* Dump various DFA statistics to FILE.  */
 334
 335 void
 336 dump_dfa_stats (FILE *file)
 337 {
 338   struct dfa_stats_d dfa_stats;
 339
 340   unsigned long size, total = 0;
 341   const char * const fmt_str   = "%-30s%-13s%12s\n";
 342   const char * const fmt_str_1 = "%-30s%13lu%11lu%c\n";
 343   const char * const fmt_str_3 = "%-43s%11lu%c\n";
 344   const char *funcname
 345     = lang_hooks.decl_printable_name (current_function_decl, 2);
 346
 347   collect_dfa_stats (&dfa_stats);
 348
 349   fprintf (file, "\nDFA Statistics for %s\n\n", funcname);
 350
 351   fprintf (file, "---------------------------------------------------------\n");
 352   fprintf (file, fmt_str, "", "  Number of  ", "Memory");
 353   fprintf (file, fmt_str, "", "  instances  ", "used ");
 354   fprintf (file, "---------------------------------------------------------\n");
 355
 356   size = num_referenced_vars * sizeof (tree);
 357   total += size;
 358   fprintf (file, fmt_str_1, "Referenced variables", (unsigned long)num_referenced_vars,
 359            SCALE (size), LABEL (size));
 360
 361   size = dfa_stats.num_stmt_anns * sizeof (struct stmt_ann_d);
 362   total += size;
 363   fprintf (file, fmt_str_1, "Statements annotated", dfa_stats.num_stmt_anns,
 364            SCALE (size), LABEL (size));
 365
 366   size = dfa_stats.num_var_anns * sizeof (struct var_ann_d);
 367   total += size;
 368   fprintf (file, fmt_str_1, "Variables annotated", dfa_stats.num_var_anns,
 369            SCALE (size), LABEL (size));
 370
 371   size = dfa_stats.num_uses * sizeof (tree *);
 372   total += size;
 373   fprintf (file, fmt_str_1, "USE operands", dfa_stats.num_uses,
 374            SCALE (size), LABEL (size));
 375
 376   size = dfa_stats.num_defs * sizeof (tree *);
 377   total += size;
 378   fprintf (file, fmt_str_1, "DEF operands", dfa_stats.num_defs,
 379            SCALE (size), LABEL (size));
 380
 381   size = dfa_stats.num_vuses * sizeof (tree *);
 382   total += size;
 383   fprintf (file, fmt_str_1, "VUSE operands", dfa_stats.num_vuses,
 384            SCALE (size), LABEL (size));
 385
 386   size = dfa_stats.num_v_may_defs * sizeof (tree *);
 387   total += size;
 388   fprintf (file, fmt_str_1, "V_MAY_DEF operands", dfa_stats.num_v_may_defs,
 389            SCALE (size), LABEL (size));
 390
 391   size = dfa_stats.num_v_must_defs * sizeof (tree *);
 392   total += size;
 393   fprintf (file, fmt_str_1, "V_MUST_DEF operands", dfa_stats.num_v_must_defs,
 394            SCALE (size), LABEL (size));
 395
 396   size = dfa_stats.num_phis * sizeof (struct tree_phi_node);
 397   total += size;
 398   fprintf (file, fmt_str_1, "PHI nodes", dfa_stats.num_phis,
 399            SCALE (size), LABEL (size));
 400
 401   size = dfa_stats.num_phi_args * sizeof (struct phi_arg_d);
 402   total += size;
 403   fprintf (file, fmt_str_1, "PHI arguments", dfa_stats.num_phi_args,
 404            SCALE (size), LABEL (size));
 405
 406   fprintf (file, "---------------------------------------------------------\n");
 407   fprintf (file, fmt_str_3, "Total memory used by DFA/SSA data", SCALE (total),
 408            LABEL (total));
 409   fprintf (file, "---------------------------------------------------------\n");
 410   fprintf (file, "\n");
 411
 412   if (dfa_stats.num_phis)
 413     fprintf (file, "Average number of arguments per PHI node: %.1f (max: %d)\n",
 414              (float) dfa_stats.num_phi_args / (float) dfa_stats.num_phis,
 415              dfa_stats.max_num_phi_args);
 416
 417   fprintf (file, "\n");
 418 }
 419
 420
 421 /* Dump DFA statistics on stderr.  */
 422
 423 void
 424 debug_dfa_stats (void)
 425 {
 426   dump_dfa_stats (stderr);
 427 }
 428
 429
 430 /* Collect DFA statistics and store them in the structure pointed by
 431    DFA_STATS_P.  */
 432
 433 static void
 434 collect_dfa_stats (struct dfa_stats_d *dfa_stats_p)
 435 {
 436   struct pointer_set_t *pset;
 437   basic_block bb;
 438   block_stmt_iterator i;
 439
 440   gcc_assert (dfa_stats_p);
 441
 442   memset ((void *)dfa_stats_p, 0, sizeof (struct dfa_stats_d));
 443
 444   /* Walk all the trees in the function counting references.  Start at
 445      basic block 0, but don't stop at block boundaries.  */
 446   pset = pointer_set_create ();
 447
 448   for (i = bsi_start (BASIC_BLOCK (0)); !bsi_end_p (i); bsi_next (&i))
 449     walk_tree (bsi_stmt_ptr (i), collect_dfa_stats_r, (void *) dfa_stats_p,
 450                pset);
 451
 452   pointer_set_destroy (pset);
 453
 454   FOR_EACH_BB (bb)
 455     {
 456       tree phi;
 457       for (phi = phi_nodes (bb); phi; phi = PHI_CHAIN (phi))
 458         {
 459           dfa_stats_p->num_phis++;
 460           dfa_stats_p->num_phi_args += PHI_NUM_ARGS (phi);
 461           if (PHI_NUM_ARGS (phi) > dfa_stats_p->max_num_phi_args)
 462             dfa_stats_p->max_num_phi_args = PHI_NUM_ARGS (phi);
 463         }
 464     }
 465 }
 466
 467
 468 /* Callback for walk_tree to collect DFA statistics for a tree and its
 469    children.  */
 470
 471 static tree
 472 collect_dfa_stats_r (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED,
 473                      void *data)
 474 {
 475   tree t = *tp;
 476   struct dfa_stats_d *dfa_stats_p = (struct dfa_stats_d *)data;
 477
 478   if (t->common.ann)
 479     {
 480       switch (ann_type (t->common.ann))
 481         {
 482         case STMT_ANN:
 483           {
 484             dfa_stats_p->num_stmt_anns++;
 485             dfa_stats_p->num_defs += NUM_SSA_OPERANDS (t, SSA_OP_DEF);
 486             dfa_stats_p->num_uses += NUM_SSA_OPERANDS (t, SSA_OP_USE);
 487             dfa_stats_p->num_v_may_defs += NUM_SSA_OPERANDS (t, SSA_OP_VMAYDEF);
 488             dfa_stats_p->num_vuses += NUM_SSA_OPERANDS (t, SSA_OP_VUSE);
 489             dfa_stats_p->num_v_must_defs +=
 490                                   NUM_SSA_OPERANDS (t, SSA_OP_VMUSTDEF);
 491             break;
 492           }
 493
 494         case VAR_ANN:
 495           dfa_stats_p->num_var_anns++;
 496           break;
 497
 498         default:
 499           break;
 500         }
 501     }
 502
 503   return NULL;
 504 }
 505
 506
 507 /*---------------------------------------------------------------------------
 508                              Miscellaneous helpers
 509 ---------------------------------------------------------------------------*/
 510 /* Callback for walk_tree.  Used to collect variables referenced in
 511    the function.  */
 512
 513 static tree
 514 find_vars_r (tree *tp, int *walk_subtrees, void *data)
 515 {
 516   struct walk_state *walk_state = (struct walk_state *) data;
 517
 518   /* If T is a regular variable that the optimizers are interested
 519      in, add it to the list of variables.  */
 520   if (SSA_VAR_P (*tp))
 521     add_referenced_var (*tp, walk_state);
 522
 523   /* Type, _DECL and constant nodes have no interesting children.
 524      Ignore them.  */
 525   else if (IS_TYPE_OR_DECL_P (*tp) || CONSTANT_CLASS_P (*tp))
 526     *walk_subtrees = 0;
 527
 528   return NULL_TREE;
 529 }
 530
 531
 532 /* Add VAR to the list of dereferenced variables.
 533
 534    WALK_STATE contains a hash table used to avoid adding the same
 535       variable more than once. Note that this function assumes that
 536       VAR is a valid SSA variable.  If WALK_STATE is NULL, no
 537       duplicate checking is done.  */
 538
 539 static void
 540 add_referenced_var (tree var, struct walk_state *walk_state)
 541 {
 542   void **slot;
 543   var_ann_t v_ann;
 544
 545   v_ann = get_var_ann (var);
 546
 547   if (walk_state)
 548     slot = htab_find_slot (walk_state->vars_found, (void *) var, INSERT);
 549   else
 550     slot = NULL;
 551
 552   if (slot == NULL || *slot == NULL)
 553     {
 554       /* This is the first time we find this variable, add it to the
 555          REFERENCED_VARS array and annotate it with attributes that are
 556          intrinsic to the variable.  */
 557       if (slot)
 558         *slot = (void *) var;
 559       v_ann->uid = num_referenced_vars;
 560       VEC_safe_push (tree, gc, referenced_vars, var);
 561
 562       /* Global variables are always call-clobbered.  */
 563       if (is_global_var (var))
 564         mark_call_clobbered (var);
 565
 566       /* Scan DECL_INITIAL for pointer variables as they may contain
 567          address arithmetic referencing the address of other
 568          variables.  */
 569       if (DECL_INITIAL (var)
 570           /* Initializers of external variables are not useful to the
 571              optimizers.  */
 572           && !DECL_EXTERNAL (var)
 573           /* It's not necessary to walk the initial value of non-constant
 574              public variables because it cannot be propagated by the
 575              optimizers.  */
 576           && (!TREE_PUBLIC (var) || !TREE_CONSTANT (var)))
 577         walk_tree (&DECL_INITIAL (var), find_vars_r, walk_state, 0);
 578     }
 579 }
 580
 581
 582 /* Return the virtual variable associated to the non-scalar variable VAR.  */
 583
 584 tree
 585 get_virtual_var (tree var)
 586 {
 587   STRIP_NOPS (var);
 588
 589   if (TREE_CODE (var) == SSA_NAME)
 590     var = SSA_NAME_VAR (var);
 591
 592   while (TREE_CODE (var) == REALPART_EXPR || TREE_CODE (var) == IMAGPART_EXPR
 593          || handled_component_p (var))
 594     var = TREE_OPERAND (var, 0);
 595
 596   /* Treating GIMPLE registers as virtual variables makes no sense.
 597      Also complain if we couldn't extract a _DECL out of the original
 598      expression.  */
 599   gcc_assert (SSA_VAR_P (var));
 600   gcc_assert (!is_gimple_reg (var));
 601
 602   return var;
 603 }
 604
 605 /* Add a temporary variable to REFERENCED_VARS.  This is similar to
 606    add_referenced_var, but is used by passes that need to add new temps to
 607    the REFERENCED_VARS array after the program has been scanned for
 608    variables.  The variable will just receive a new UID and be added
 609    to the REFERENCED_VARS array without checking for duplicates.  */
 610
 611 void
 612 add_referenced_tmp_var (tree var)
 613 {
 614   add_referenced_var (var, NULL);
 615 }
 616
 617
 618 /* Mark all the non-SSA variables found in STMT's operands to be
 619    processed by update_ssa.  */
 620
 621 void
 622 mark_new_vars_to_rename (tree stmt)
 623 {
 624   ssa_op_iter iter;
 625   tree val;
 626   bitmap vars_in_vops_to_rename;
 627   bool found_exposed_symbol = false;
 628   int v_may_defs_before, v_may_defs_after;
 629   int v_must_defs_before, v_must_defs_after;
 630
 631   vars_in_vops_to_rename = BITMAP_ALLOC (NULL);
 632
 633   /* Before re-scanning the statement for operands, mark the existing
 634      virtual operands to be renamed again.  We do this because when new
 635      symbols are exposed, the virtual operands that were here before due to
 636      aliasing will probably be removed by the call to get_stmt_operand.
 637      Therefore, we need to flag them to be renamed beforehand.
 638
 639      We flag them in a separate bitmap because we don't really want to
 640      rename them if there are not any newly exposed symbols in the
 641      statement operands.  */
 642   v_may_defs_before = NUM_SSA_OPERANDS (stmt, SSA_OP_VMAYDEF);
 643   v_must_defs_before = NUM_SSA_OPERANDS (stmt, SSA_OP_VMUSTDEF);
 644
 645   FOR_EACH_SSA_TREE_OPERAND (val, stmt, iter,
 646                              SSA_OP_VMAYDEF | SSA_OP_VUSE | SSA_OP_VMUSTDEF)
 647     {
 648       if (!DECL_P (val))
 649         val = SSA_NAME_VAR (val);
 650       bitmap_set_bit (vars_in_vops_to_rename, var_ann (val)->uid);
 651     }
 652
 653   /* Now force an operand re-scan on the statement and mark any newly
 654      exposed variables.  */
 655   update_stmt (stmt);
 656
 657   v_may_defs_after = NUM_SSA_OPERANDS (stmt, SSA_OP_VMAYDEF);
 658   v_must_defs_after = NUM_SSA_OPERANDS (stmt, SSA_OP_VMUSTDEF);
 659
 660   FOR_EACH_SSA_TREE_OPERAND (val, stmt, iter, SSA_OP_ALL_OPERANDS)
 661     if (DECL_P (val))
 662       {
 663         found_exposed_symbol = true;
 664         mark_sym_for_renaming (val);
 665       }
 666
 667   /* If we found any newly exposed symbols, or if there are fewer VDEF
 668      operands in the statement, add the variables we had set in
 669      VARS_IN_VOPS_TO_RENAME to VARS_TO_RENAME.  We need to check for
 670      vanishing VDEFs because in those cases, the names that were formerly
 671      generated by this statement are not going to be available anymore.  */
 672   if (found_exposed_symbol
 673       || v_may_defs_before > v_may_defs_after
 674       || v_must_defs_before > v_must_defs_after)
 675     mark_set_for_renaming (vars_in_vops_to_rename);
 676
 677   BITMAP_FREE (vars_in_vops_to_rename);
 678 }
 679
 680 /* Find all variables within the gimplified statement that were not previously
 681    visible to the function and add them to the referenced variables list.  */
 682
 683 static tree
 684 find_new_referenced_vars_1 (tree *tp, int *walk_subtrees,
 685                             void *data ATTRIBUTE_UNUSED)
 686 {
 687   tree t = *tp;
 688
 689   if (TREE_CODE (t) == VAR_DECL && !var_ann (t))
 690     {
 691       add_referenced_tmp_var (t);
 692       mark_sym_for_renaming (t);
 693     }
 694
 695   if (IS_TYPE_OR_DECL_P (t))
 696     *walk_subtrees = 0;
 697
 698   return NULL;
 699 }
 700
 701 void
 702 find_new_referenced_vars (tree *stmt_p)
 703 {
 704   walk_tree (stmt_p, find_new_referenced_vars_1, NULL, NULL);
 705 }
 706
 707
 708 /* If REF is a COMPONENT_REF for a structure that can have sub-variables, and
 709    we know where REF is accessing, return the variable in REF that has the
 710    sub-variables.  If the return value is not NULL, POFFSET will be the
 711    offset, in bits, of REF inside the return value, and PSIZE will be the
 712    size, in bits, of REF inside the return value.  */
 713
 714 tree
 715 okay_component_ref_for_subvars (tree ref, HOST_WIDE_INT *poffset,
 716                                 HOST_WIDE_INT *psize)
 717 {
 718   tree result = NULL;
 719   HOST_WIDE_INT bitsize;
 720   HOST_WIDE_INT bitpos;
 721   tree offset;
 722   enum machine_mode mode;
 723   int unsignedp;
 724   int volatilep;
 725
 726   gcc_assert (!SSA_VAR_P (ref));
 727   *poffset = 0;
 728   *psize = (unsigned int) -1;
 729
 730   if (ref_contains_array_ref (ref))
 731     return result;
 732   ref = get_inner_reference (ref, &bitsize, &bitpos, &offset, &mode,
 733                              &unsignedp, &volatilep, false);
 734   if (TREE_CODE (ref) == INDIRECT_REF)
 735     return result;
 736   else if (offset == NULL && bitsize != -1 && SSA_VAR_P (ref))
 737     {
 738       *poffset = bitpos;
 739       *psize = bitsize;
 740       if (get_subvars_for_var (ref) != NULL)
 741         return ref;
 742     }
 743   else if (SSA_VAR_P (ref))
 744     {
 745       if (get_subvars_for_var (ref) != NULL)
 746         return ref;
 747     }
 748   return NULL_TREE;
 749 }