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 /* Default definition for this symbols.  If set for symbol, it
  89    means that the first reference to this variable in the function is a
  90    USE or a VUSE.  In those cases, the SSA renamer creates an SSA name
  91    for this variable with an empty defining statement.  */
  92 htab_t default_defs;
  93
  94
  95 /*---------------------------------------------------------------------------
  96                         Dataflow analysis (DFA) routines
  97 ---------------------------------------------------------------------------*/
  98 /* Find all the variables referenced in the function.  This function
  99    builds the global arrays REFERENCED_VARS and CALL_CLOBBERED_VARS.
 100
 101    Note that this function does not look for statement operands, it simply
 102    determines what variables are referenced in the program and detects
 103    various attributes for each variable used by alias analysis and the
 104    optimizer.  */
 105
 106 static unsigned int
 107 find_referenced_vars (void)
 108 {
 109   htab_t vars_found;
 110   basic_block bb;
 111   block_stmt_iterator si;
 112   struct walk_state walk_state;
 113
 114   vars_found = htab_create (50, htab_hash_pointer, htab_eq_pointer, NULL);
 115   memset (&walk_state, 0, sizeof (walk_state));
 116   walk_state.vars_found = vars_found;
 117
 118   FOR_EACH_BB (bb)
 119     for (si = bsi_start (bb); !bsi_end_p (si); bsi_next (&si))
 120       {
 121         tree *stmt_p = bsi_stmt_ptr (si);
 122         walk_tree (stmt_p, find_vars_r, &walk_state, NULL);
 123       }
 124
 125   htab_delete (vars_found);
 126   return 0;
 127 }
 128
 129 struct tree_opt_pass pass_referenced_vars =
 130 {
 131   NULL,                                 /* name */
 132   NULL,                                 /* gate */
 133   find_referenced_vars,                 /* execute */
 134   NULL,                                 /* sub */
 135   NULL,                                 /* next */
 136   0,                                    /* static_pass_number */
 137   TV_FIND_REFERENCED_VARS,              /* tv_id */
 138   PROP_gimple_leh | PROP_cfg,           /* properties_required */
 139   PROP_referenced_vars,                 /* properties_provided */
 140   0,                                    /* properties_destroyed */
 141   0,                                    /* todo_flags_start */
 142   0,                                    /* todo_flags_finish */
 143   0                                     /* letter */
 144 };
 145
 146
 147 /*---------------------------------------------------------------------------
 148                             Manage annotations
 149 ---------------------------------------------------------------------------*/
 150 /* Create a new annotation for a _DECL node T.  */
 151
 152 var_ann_t
 153 create_var_ann (tree t)
 154 {
 155   var_ann_t ann;
 156
 157   gcc_assert (t);
 158   gcc_assert (DECL_P (t));
 159   gcc_assert (!t->common.ann || t->common.ann->common.type == VAR_ANN);
 160
 161   ann = GGC_NEW (struct var_ann_d);
 162   memset ((void *) ann, 0, sizeof (*ann));
 163
 164   ann->common.type = VAR_ANN;
 165
 166   t->common.ann = (tree_ann_t) ann;
 167
 168   return ann;
 169 }
 170
 171 /* Create a new annotation for a FUNCTION_DECL node T.  */
 172
 173 function_ann_t
 174 create_function_ann (tree t)
 175 {
 176   function_ann_t ann;
 177
 178   gcc_assert (t);
 179   gcc_assert (TREE_CODE (t) == FUNCTION_DECL);
 180   gcc_assert (!t->common.ann || t->common.ann->common.type == FUNCTION_ANN);
 181
 182   ann = ggc_alloc (sizeof (*ann));
 183   memset ((void *) ann, 0, sizeof (*ann));
 184
 185   ann->common.type = FUNCTION_ANN;
 186
 187   t->common.ann = (tree_ann_t) ann;
 188
 189   return ann;
 190 }
 191
 192 /* Create a new annotation for a statement node T.  */
 193
 194 stmt_ann_t
 195 create_stmt_ann (tree t)
 196 {
 197   stmt_ann_t ann;
 198
 199   gcc_assert (is_gimple_stmt (t));
 200   gcc_assert (!t->common.ann || t->common.ann->common.type == STMT_ANN);
 201
 202   ann = GGC_NEW (struct stmt_ann_d);
 203   memset ((void *) ann, 0, sizeof (*ann));
 204
 205   ann->common.type = STMT_ANN;
 206
 207   /* Since we just created the annotation, mark the statement modified.  */
 208   ann->modified = true;
 209
 210   t->common.ann = (tree_ann_t) ann;
 211
 212   return ann;
 213 }
 214
 215 /* Create a new annotation for a tree T.  */
 216
 217 tree_ann_t
 218 create_tree_ann (tree t)
 219 {
 220   tree_ann_t ann;
 221
 222   gcc_assert (t);
 223   gcc_assert (!t->common.ann || t->common.ann->common.type == TREE_ANN_COMMON);
 224
 225   ann = GGC_NEW (union tree_ann_d);
 226   memset ((void *) ann, 0, sizeof (*ann));
 227
 228   ann->common.type = TREE_ANN_COMMON;
 229   t->common.ann = ann;
 230
 231   return ann;
 232 }
 233
 234 /* Build a temporary.  Make sure and register it to be renamed.  */
 235
 236 tree
 237 make_rename_temp (tree type, const char *prefix)
 238 {
 239   tree t = create_tmp_var (type, prefix);
 240
 241   if (TREE_CODE (type) == COMPLEX_TYPE)
 242     DECL_COMPLEX_GIMPLE_REG_P (t) = 1;
 243
 244   if (referenced_vars)
 245     {
 246       add_referenced_tmp_var (t);
 247       mark_sym_for_renaming (t);
 248     }
 249
 250   return t;
 251 }
 252
 253
 254
 255 /*---------------------------------------------------------------------------
 256                               Debugging functions
 257 ---------------------------------------------------------------------------*/
 258 /* Dump the list of all the referenced variables in the current function to
 259    FILE.  */
 260
 261 void
 262 dump_referenced_vars (FILE *file)
 263 {
 264   tree var;
 265   referenced_var_iterator rvi;
 266
 267   fprintf (file, "\nReferenced variables in %s: %u\n\n",
 268            get_name (current_function_decl), (unsigned) num_referenced_vars);
 269
 270   FOR_EACH_REFERENCED_VAR (var, rvi)
 271     {
 272       fprintf (file, "Variable: ");
 273       dump_variable (file, var);
 274       fprintf (file, "\n");
 275     }
 276 }
 277
 278
 279 /* Dump the list of all the referenced variables to stderr.  */
 280
 281 void
 282 debug_referenced_vars (void)
 283 {
 284   dump_referenced_vars (stderr);
 285 }
 286
 287
 288 /* Dump sub-variables for VAR to FILE.  */
 289
 290 void
 291 dump_subvars_for (FILE *file, tree var)
 292 {
 293   subvar_t sv = get_subvars_for_var (var);
 294
 295   if (!sv)
 296     return;
 297
 298   fprintf (file, "{ ");
 299
 300   for (; sv; sv = sv->next)
 301     {
 302       print_generic_expr (file, sv->var, dump_flags);
 303       fprintf (file, " ");
 304     }
 305
 306   fprintf (file, "}");
 307 }
 308
 309
 310 /* Dumb sub-variables for VAR to stderr.  */
 311
 312 void
 313 debug_subvars_for (tree var)
 314 {
 315   dump_subvars_for (stderr, var);
 316 }
 317
 318
 319 /* Dump variable VAR and its may-aliases to FILE.  */
 320
 321 void
 322 dump_variable (FILE *file, tree var)
 323 {
 324   var_ann_t ann;
 325
 326   if (TREE_CODE (var) == SSA_NAME)
 327     {
 328       if (POINTER_TYPE_P (TREE_TYPE (var)))
 329         dump_points_to_info_for (file, var);
 330       var = SSA_NAME_VAR (var);
 331     }
 332
 333   if (var == NULL_TREE)
 334     {
 335       fprintf (file, "<nil>");
 336       return;
 337     }
 338
 339   print_generic_expr (file, var, dump_flags);
 340
 341   ann = var_ann (var);
 342
 343   fprintf (file, ", UID %u", (unsigned) DECL_UID (var));
 344
 345   fprintf (file, ", ");
 346   print_generic_expr (file, TREE_TYPE (var), dump_flags);
 347
 348   if (ann && ann->symbol_mem_tag)
 349     {
 350       fprintf (file, ", symbol memory tag: ");
 351       print_generic_expr (file, ann->symbol_mem_tag, dump_flags);
 352     }
 353
 354   if (ann && ann->is_aliased)
 355     fprintf (file, ", is aliased");
 356
 357   if (TREE_ADDRESSABLE (var))
 358     fprintf (file, ", is addressable");
 359
 360   if (is_global_var (var))
 361     fprintf (file, ", is global");
 362
 363   if (TREE_THIS_VOLATILE (var))
 364     fprintf (file, ", is volatile");
 365
 366   if (is_call_clobbered (var))
 367     {
 368       fprintf (file, ", call clobbered");
 369       if (dump_flags & TDF_DETAILS)
 370         {
 371           var_ann_t va = var_ann (var);
 372           unsigned int escape_mask = va->escape_mask;
 373
 374           fprintf (file, " (");
 375           if (escape_mask & ESCAPE_STORED_IN_GLOBAL)
 376             fprintf (file, ", stored in global");
 377           if (escape_mask & ESCAPE_TO_ASM)
 378             fprintf (file, ", goes through ASM");
 379           if (escape_mask & ESCAPE_TO_CALL)
 380             fprintf (file, ", passed to call");
 381           if (escape_mask & ESCAPE_BAD_CAST)
 382             fprintf (file, ", bad cast");
 383           if (escape_mask & ESCAPE_TO_RETURN)
 384             fprintf (file, ", returned from func");
 385           if (escape_mask & ESCAPE_TO_PURE_CONST)
 386             fprintf (file, ", passed to pure/const");
 387           if (escape_mask & ESCAPE_IS_GLOBAL)
 388             fprintf (file, ", is global var");
 389           if (escape_mask & ESCAPE_IS_PARM)
 390             fprintf (file, ", is incoming pointer");
 391           if (escape_mask & ESCAPE_UNKNOWN)
 392             fprintf (file, ", unknown escape");
 393           fprintf (file, " )");
 394         }
 395     }
 396
 397   if (default_def (var))
 398     {
 399       fprintf (file, ", default def: ");
 400       print_generic_expr (file, default_def (var), dump_flags);
 401     }
 402
 403   if (may_aliases (var))
 404     {
 405       fprintf (file, ", may aliases: ");
 406       dump_may_aliases_for (file, var);
 407     }
 408
 409   if (get_subvars_for_var (var))
 410     {
 411       fprintf (file, ", sub-vars: ");
 412       dump_subvars_for (file, var);
 413     }
 414
 415   fprintf (file, "\n");
 416 }
 417
 418
 419 /* Dump variable VAR and its may-aliases to stderr.  */
 420
 421 void
 422 debug_variable (tree var)
 423 {
 424   dump_variable (stderr, var);
 425 }
 426
 427
 428 /* Dump various DFA statistics to FILE.  */
 429
 430 void
 431 dump_dfa_stats (FILE *file)
 432 {
 433   struct dfa_stats_d dfa_stats;
 434
 435   unsigned long size, total = 0;
 436   const char * const fmt_str   = "%-30s%-13s%12s\n";
 437   const char * const fmt_str_1 = "%-30s%13lu%11lu%c\n";
 438   const char * const fmt_str_3 = "%-43s%11lu%c\n";
 439   const char *funcname
 440     = lang_hooks.decl_printable_name (current_function_decl, 2);
 441
 442   collect_dfa_stats (&dfa_stats);
 443
 444   fprintf (file, "\nDFA Statistics for %s\n\n", funcname);
 445
 446   fprintf (file, "---------------------------------------------------------\n");
 447   fprintf (file, fmt_str, "", "  Number of  ", "Memory");
 448   fprintf (file, fmt_str, "", "  instances  ", "used ");
 449   fprintf (file, "---------------------------------------------------------\n");
 450
 451   size = num_referenced_vars * sizeof (tree);
 452   total += size;
 453   fprintf (file, fmt_str_1, "Referenced variables", (unsigned long)num_referenced_vars,
 454            SCALE (size), LABEL (size));
 455
 456   size = dfa_stats.num_stmt_anns * sizeof (struct stmt_ann_d);
 457   total += size;
 458   fprintf (file, fmt_str_1, "Statements annotated", dfa_stats.num_stmt_anns,
 459            SCALE (size), LABEL (size));
 460
 461   size = dfa_stats.num_var_anns * sizeof (struct var_ann_d);
 462   total += size;
 463   fprintf (file, fmt_str_1, "Variables annotated", dfa_stats.num_var_anns,
 464            SCALE (size), LABEL (size));
 465
 466   size = dfa_stats.num_uses * sizeof (tree *);
 467   total += size;
 468   fprintf (file, fmt_str_1, "USE operands", dfa_stats.num_uses,
 469            SCALE (size), LABEL (size));
 470
 471   size = dfa_stats.num_defs * sizeof (tree *);
 472   total += size;
 473   fprintf (file, fmt_str_1, "DEF operands", dfa_stats.num_defs,
 474            SCALE (size), LABEL (size));
 475
 476   size = dfa_stats.num_vuses * sizeof (tree *);
 477   total += size;
 478   fprintf (file, fmt_str_1, "VUSE operands", dfa_stats.num_vuses,
 479            SCALE (size), LABEL (size));
 480
 481   size = dfa_stats.num_v_may_defs * sizeof (tree *);
 482   total += size;
 483   fprintf (file, fmt_str_1, "V_MAY_DEF operands", dfa_stats.num_v_may_defs,
 484            SCALE (size), LABEL (size));
 485
 486   size = dfa_stats.num_v_must_defs * sizeof (tree *);
 487   total += size;
 488   fprintf (file, fmt_str_1, "V_MUST_DEF operands", dfa_stats.num_v_must_defs,
 489            SCALE (size), LABEL (size));
 490
 491   size = dfa_stats.num_phis * sizeof (struct tree_phi_node);
 492   total += size;
 493   fprintf (file, fmt_str_1, "PHI nodes", dfa_stats.num_phis,
 494            SCALE (size), LABEL (size));
 495
 496   size = dfa_stats.num_phi_args * sizeof (struct phi_arg_d);
 497   total += size;
 498   fprintf (file, fmt_str_1, "PHI arguments", dfa_stats.num_phi_args,
 499            SCALE (size), LABEL (size));
 500
 501   fprintf (file, "---------------------------------------------------------\n");
 502   fprintf (file, fmt_str_3, "Total memory used by DFA/SSA data", SCALE (total),
 503            LABEL (total));
 504   fprintf (file, "---------------------------------------------------------\n");
 505   fprintf (file, "\n");
 506
 507   if (dfa_stats.num_phis)
 508     fprintf (file, "Average number of arguments per PHI node: %.1f (max: %d)\n",
 509              (float) dfa_stats.num_phi_args / (float) dfa_stats.num_phis,
 510              dfa_stats.max_num_phi_args);
 511
 512   fprintf (file, "\n");
 513 }
 514
 515
 516 /* Dump DFA statistics on stderr.  */
 517
 518 void
 519 debug_dfa_stats (void)
 520 {
 521   dump_dfa_stats (stderr);
 522 }
 523
 524
 525 /* Collect DFA statistics and store them in the structure pointed to by
 526    DFA_STATS_P.  */
 527
 528 static void
 529 collect_dfa_stats (struct dfa_stats_d *dfa_stats_p)
 530 {
 531   struct pointer_set_t *pset;
 532   basic_block bb;
 533   block_stmt_iterator i;
 534
 535   gcc_assert (dfa_stats_p);
 536
 537   memset ((void *)dfa_stats_p, 0, sizeof (struct dfa_stats_d));
 538
 539   /* Walk all the trees in the function counting references.  Start at
 540      basic block NUM_FIXED_BLOCKS, but don't stop at block boundaries.  */
 541   pset = pointer_set_create ();
 542
 543   for (i = bsi_start (BASIC_BLOCK (NUM_FIXED_BLOCKS));
 544        !bsi_end_p (i); bsi_next (&i))
 545     walk_tree (bsi_stmt_ptr (i), collect_dfa_stats_r, (void *) dfa_stats_p,
 546                pset);
 547
 548   pointer_set_destroy (pset);
 549
 550   FOR_EACH_BB (bb)
 551     {
 552       tree phi;
 553       for (phi = phi_nodes (bb); phi; phi = PHI_CHAIN (phi))
 554         {
 555           dfa_stats_p->num_phis++;
 556           dfa_stats_p->num_phi_args += PHI_NUM_ARGS (phi);
 557           if (PHI_NUM_ARGS (phi) > dfa_stats_p->max_num_phi_args)
 558             dfa_stats_p->max_num_phi_args = PHI_NUM_ARGS (phi);
 559         }
 560     }
 561 }
 562
 563
 564 /* Callback for walk_tree to collect DFA statistics for a tree and its
 565    children.  */
 566
 567 static tree
 568 collect_dfa_stats_r (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED,
 569                      void *data)
 570 {
 571   tree t = *tp;
 572   struct dfa_stats_d *dfa_stats_p = (struct dfa_stats_d *)data;
 573
 574   if (t->common.ann)
 575     {
 576       switch (ann_type (t->common.ann))
 577         {
 578         case STMT_ANN:
 579           {
 580             dfa_stats_p->num_stmt_anns++;
 581             dfa_stats_p->num_defs += NUM_SSA_OPERANDS (t, SSA_OP_DEF);
 582             dfa_stats_p->num_uses += NUM_SSA_OPERANDS (t, SSA_OP_USE);
 583             dfa_stats_p->num_v_may_defs += NUM_SSA_OPERANDS (t, SSA_OP_VMAYDEF);
 584             dfa_stats_p->num_vuses += NUM_SSA_OPERANDS (t, SSA_OP_VUSE);
 585             dfa_stats_p->num_v_must_defs +=
 586                                   NUM_SSA_OPERANDS (t, SSA_OP_VMUSTDEF);
 587             break;
 588           }
 589
 590         case VAR_ANN:
 591           dfa_stats_p->num_var_anns++;
 592           break;
 593
 594         default:
 595           break;
 596         }
 597     }
 598
 599   return NULL;
 600 }
 601
 602
 603 /*---------------------------------------------------------------------------
 604                              Miscellaneous helpers
 605 ---------------------------------------------------------------------------*/
 606 /* Callback for walk_tree.  Used to collect variables referenced in
 607    the function.  */
 608
 609 static tree
 610 find_vars_r (tree *tp, int *walk_subtrees, void *data)
 611 {
 612   struct walk_state *walk_state = (struct walk_state *) data;
 613
 614   /* If T is a regular variable that the optimizers are interested
 615      in, add it to the list of variables.  */
 616   if (SSA_VAR_P (*tp))
 617     add_referenced_var (*tp, walk_state);
 618
 619   /* Type, _DECL and constant nodes have no interesting children.
 620      Ignore them.  */
 621   else if (IS_TYPE_OR_DECL_P (*tp) || CONSTANT_CLASS_P (*tp))
 622     *walk_subtrees = 0;
 623
 624   return NULL_TREE;
 625 }
 626
 627
 628 /* Lookup UID in the referenced_vars hashtable and return the associated
 629    variable or NULL if it is not there.  */
 630
 631 tree
 632 referenced_var_lookup_if_exists (unsigned int uid)
 633 {
 634   struct int_tree_map *h, in;
 635   in.uid = uid;
 636   h = (struct int_tree_map *) htab_find_with_hash (referenced_vars, &in, uid);
 637   if (h)
 638     return h->to;
 639   return NULL_TREE;
 640 }
 641
 642 /* Lookup UID in the referenced_vars hashtable and return the associated
 643    variable.  */
 644
 645 tree
 646 referenced_var_lookup (unsigned int uid)
 647 {
 648   struct int_tree_map *h, in;
 649   in.uid = uid;
 650   h = (struct int_tree_map *) htab_find_with_hash (referenced_vars, &in, uid);
 651   gcc_assert (h || uid == 0);
 652   if (h)
 653     return h->to;
 654   return NULL_TREE;
 655 }
 656
 657 /* Insert the pair UID, TO into the referenced_vars hashtable.  */
 658
 659 static void
 660 referenced_var_insert (unsigned int uid, tree to)
 661 {
 662   struct int_tree_map *h;
 663   void **loc;
 664
 665   h = GGC_NEW (struct int_tree_map);
 666   h->uid = uid;
 667   h->to = to;
 668   loc = htab_find_slot_with_hash (referenced_vars, h, uid, INSERT);
 669   *(struct int_tree_map **)  loc = h;
 670 }
 671
 672 /* Lookup VAR UID in the default_defs hashtable and return the associated
 673    variable.  */
 674
 675 tree
 676 default_def (tree var)
 677 {
 678   struct int_tree_map *h, in;
 679   gcc_assert (SSA_VAR_P (var));
 680   in.uid = DECL_UID (var);
 681   h = (struct int_tree_map *) htab_find_with_hash (default_defs, &in,
 682                                                    DECL_UID (var));
 683   if (h)
 684     return h->to;
 685   return NULL_TREE;
 686 }
 687
 688 /* Insert the pair VAR's UID, DEF into the default_defs hashtable.  */
 689
 690 void
 691 set_default_def (tree var, tree def)
 692 {
 693   struct int_tree_map in;
 694   struct int_tree_map *h;
 695   void **loc;
 696
 697   gcc_assert (SSA_VAR_P (var));
 698   in.uid = DECL_UID (var);
 699   if (!def && default_def (var))
 700     {
 701       loc = htab_find_slot_with_hash (default_defs, &in, DECL_UID (var), INSERT);
 702       htab_remove_elt (default_defs, *loc);
 703       return;
 704     }
 705   gcc_assert (TREE_CODE (def) == SSA_NAME);
 706   loc = htab_find_slot_with_hash (default_defs, &in, DECL_UID (var), INSERT);
 707   /* Default definition might be changed by tail call optimization.  */
 708   if (!*loc)
 709     {
 710       h = GGC_NEW (struct int_tree_map);
 711       h->uid = DECL_UID (var);
 712       h->to = def;
 713       *(struct int_tree_map **)  loc = h;
 714     }
 715    else
 716     {
 717       h = (struct int_tree_map *) *loc;
 718       h->to = def;
 719     }
 720 }
 721
 722 /* Add VAR to the list of dereferenced variables.
 723
 724    WALK_STATE contains a hash table used to avoid adding the same
 725       variable more than once. Note that this function assumes that
 726       VAR is a valid SSA variable.  If WALK_STATE is NULL, no
 727       duplicate checking is done.  */
 728
 729 static void
 730 add_referenced_var (tree var, struct walk_state *walk_state)
 731 {
 732   void **slot;
 733   var_ann_t v_ann;
 734
 735   v_ann = get_var_ann (var);
 736
 737   if (walk_state)
 738     slot = htab_find_slot (walk_state->vars_found, (void *) var, INSERT);
 739   else
 740     slot = NULL;
 741
 742   if (slot == NULL || *slot == NULL)
 743     {
 744       /* This is the first time we find this variable, add it to the
 745          REFERENCED_VARS array and annotate it with attributes that are
 746          intrinsic to the variable.  */
 747       if (slot)
 748         *slot = (void *) var;
 749
 750       referenced_var_insert (DECL_UID (var), var);
 751
 752       /* Tag's don't have DECL_INITIAL.  */
 753       if (MTAG_P (var))
 754         return;
 755
 756       /* Scan DECL_INITIAL for pointer variables as they may contain
 757          address arithmetic referencing the address of other
 758          variables.  */
 759       if (DECL_INITIAL (var)
 760           /* Initializers of external variables are not useful to the
 761              optimizers.  */
 762           && !DECL_EXTERNAL (var)
 763           /* It's not necessary to walk the initial value of non-constant
 764              variables because it cannot be propagated by the
 765              optimizers.  */
 766           && (TREE_CONSTANT (var) || TREE_READONLY (var)))
 767         walk_tree (&DECL_INITIAL (var), find_vars_r, walk_state, 0);
 768     }
 769 }
 770
 771
 772 /* Return the virtual variable associated to the non-scalar variable VAR.  */
 773
 774 tree
 775 get_virtual_var (tree var)
 776 {
 777   STRIP_NOPS (var);
 778
 779   if (TREE_CODE (var) == SSA_NAME)
 780     var = SSA_NAME_VAR (var);
 781
 782   while (TREE_CODE (var) == REALPART_EXPR || TREE_CODE (var) == IMAGPART_EXPR
 783          || handled_component_p (var))
 784     var = TREE_OPERAND (var, 0);
 785
 786   /* Treating GIMPLE registers as virtual variables makes no sense.
 787      Also complain if we couldn't extract a _DECL out of the original
 788      expression.  */
 789   gcc_assert (SSA_VAR_P (var));
 790   gcc_assert (!is_gimple_reg (var));
 791
 792   return var;
 793 }
 794
 795 /* Add a temporary variable to REFERENCED_VARS.  This is similar to
 796    add_referenced_var, but is used by passes that need to add new temps to
 797    the REFERENCED_VARS array after the program has been scanned for
 798    variables.  The variable will just receive a new UID and be added
 799    to the REFERENCED_VARS array without checking for duplicates.  */
 800
 801 void
 802 add_referenced_tmp_var (tree var)
 803 {
 804   add_referenced_var (var, NULL);
 805 }
 806
 807
 808 /* Mark all the non-SSA variables found in STMT's operands to be
 809    processed by update_ssa.  */
 810
 811 void
 812 mark_new_vars_to_rename (tree stmt)
 813 {
 814   ssa_op_iter iter;
 815   tree val;
 816   bitmap vars_in_vops_to_rename;
 817   bool found_exposed_symbol = false;
 818   int v_may_defs_before, v_may_defs_after;
 819   int v_must_defs_before, v_must_defs_after;
 820
 821   if (TREE_CODE (stmt) == PHI_NODE)
 822     return;
 823
 824   get_stmt_ann (stmt);
 825   vars_in_vops_to_rename = BITMAP_ALLOC (NULL);
 826
 827   /* Before re-scanning the statement for operands, mark the existing
 828      virtual operands to be renamed again.  We do this because when new
 829      symbols are exposed, the virtual operands that were here before due to
 830      aliasing will probably be removed by the call to get_stmt_operand.
 831      Therefore, we need to flag them to be renamed beforehand.
 832
 833      We flag them in a separate bitmap because we don't really want to
 834      rename them if there are not any newly exposed symbols in the
 835      statement operands.  */
 836   v_may_defs_before = NUM_SSA_OPERANDS (stmt, SSA_OP_VMAYDEF);
 837   v_must_defs_before = NUM_SSA_OPERANDS (stmt, SSA_OP_VMUSTDEF);
 838
 839   FOR_EACH_SSA_TREE_OPERAND (val, stmt, iter,
 840                              SSA_OP_VMAYDEF | SSA_OP_VUSE | SSA_OP_VMUSTDEF)
 841     {
 842       if (!DECL_P (val))
 843         val = SSA_NAME_VAR (val);
 844       bitmap_set_bit (vars_in_vops_to_rename, DECL_UID (val));
 845     }
 846
 847   /* Now force an operand re-scan on the statement and mark any newly
 848      exposed variables.  */
 849   update_stmt (stmt);
 850
 851   v_may_defs_after = NUM_SSA_OPERANDS (stmt, SSA_OP_VMAYDEF);
 852   v_must_defs_after = NUM_SSA_OPERANDS (stmt, SSA_OP_VMUSTDEF);
 853
 854   FOR_EACH_SSA_TREE_OPERAND (val, stmt, iter, SSA_OP_ALL_OPERANDS)
 855     if (DECL_P (val))
 856       {
 857         found_exposed_symbol = true;
 858         mark_sym_for_renaming (val);
 859       }
 860
 861   /* If we found any newly exposed symbols, or if there are fewer VDEF
 862      operands in the statement, add the variables we had set in
 863      VARS_IN_VOPS_TO_RENAME to VARS_TO_RENAME.  We need to check for
 864      vanishing VDEFs because in those cases, the names that were formerly
 865      generated by this statement are not going to be available anymore.  */
 866   if (found_exposed_symbol
 867       || v_may_defs_before > v_may_defs_after
 868       || v_must_defs_before > v_must_defs_after)
 869     mark_set_for_renaming (vars_in_vops_to_rename);
 870
 871   BITMAP_FREE (vars_in_vops_to_rename);
 872 }
 873
 874 /* Find all variables within the gimplified statement that were not previously
 875    visible to the function and add them to the referenced variables list.  */
 876
 877 static tree
 878 find_new_referenced_vars_1 (tree *tp, int *walk_subtrees,
 879                             void *data ATTRIBUTE_UNUSED)
 880 {
 881   tree t = *tp;
 882
 883   if (TREE_CODE (t) == VAR_DECL && !var_ann (t))
 884     {
 885       add_referenced_tmp_var (t);
 886       mark_sym_for_renaming (t);
 887     }
 888
 889   if (IS_TYPE_OR_DECL_P (t))
 890     *walk_subtrees = 0;
 891
 892   return NULL;
 893 }
 894
 895 void
 896 find_new_referenced_vars (tree *stmt_p)
 897 {
 898   walk_tree (stmt_p, find_new_referenced_vars_1, NULL, NULL);
 899 }
 900
 901
 902 /* If REF is a handled component reference for a structure, return the
 903    base variable.  The access range is delimited by bit positions *POFFSET and
 904    *POFFSET + *PMAX_SIZE.  The access size is *PSIZE bits.  If either
 905    *PSIZE or *PMAX_SIZE is -1, they could not be determined.  If *PSIZE
 906    and *PMAX_SIZE are equal, the access is non-variable.  */
 907
 908 tree
 909 get_ref_base_and_extent (tree exp, HOST_WIDE_INT *poffset,
 910                          HOST_WIDE_INT *psize,
 911                          HOST_WIDE_INT *pmax_size)
 912 {
 913   HOST_WIDE_INT bitsize = -1;
 914   HOST_WIDE_INT maxsize = -1;
 915   tree size_tree = NULL_TREE;
 916   tree bit_offset = bitsize_zero_node;
 917   bool seen_variable_array_ref = false;
 918
 919   gcc_assert (!SSA_VAR_P (exp));
 920
 921   /* First get the final access size from just the outermost expression.  */
 922   if (TREE_CODE (exp) == COMPONENT_REF)
 923     size_tree = DECL_SIZE (TREE_OPERAND (exp, 1));
 924   else if (TREE_CODE (exp) == BIT_FIELD_REF)
 925     size_tree = TREE_OPERAND (exp, 1);
 926   else
 927     {
 928       enum machine_mode mode = TYPE_MODE (TREE_TYPE (exp));
 929       if (mode == BLKmode)
 930         size_tree = TYPE_SIZE (TREE_TYPE (exp));
 931       else
 932         bitsize = GET_MODE_BITSIZE (mode);
 933     }
 934   if (size_tree != NULL_TREE)
 935     {
 936       if (! host_integerp (size_tree, 1))
 937         bitsize = -1;
 938       else
 939         bitsize = TREE_INT_CST_LOW (size_tree);
 940     }
 941
 942   /* Initially, maxsize is the same as the accessed element size.
 943      In the following it will only grow (or become -1).  */
 944   maxsize = bitsize;
 945
 946   /* Compute cumulative bit-offset for nested component-refs and array-refs,
 947      and find the ultimate containing object.  */
 948   while (1)
 949     {
 950       switch (TREE_CODE (exp))
 951         {
 952         case BIT_FIELD_REF:
 953           bit_offset = size_binop (PLUS_EXPR, bit_offset,
 954                                    TREE_OPERAND (exp, 2));
 955           break;
 956
 957         case COMPONENT_REF:
 958           {
 959             tree field = TREE_OPERAND (exp, 1);
 960             tree this_offset = component_ref_field_offset (exp);
 961
 962             if (this_offset && TREE_CODE (this_offset) == INTEGER_CST)
 963               {
 964                 this_offset = size_binop (MULT_EXPR,
 965                                           fold_convert (bitsizetype,
 966                                                         this_offset),
 967                                           bitsize_unit_node);
 968                 bit_offset = size_binop (PLUS_EXPR,
 969                                          bit_offset, this_offset);
 970                 bit_offset = size_binop (PLUS_EXPR, bit_offset,
 971                                          DECL_FIELD_BIT_OFFSET (field));
 972               }
 973             else
 974               {
 975                 tree csize = TYPE_SIZE (TREE_TYPE (TREE_OPERAND (exp, 0)));
 976                 /* We need to adjust maxsize to the whole structure bitsize.
 977                    But we can subtract any constant offset seen sofar,
 978                    because that would get us out of the structure otherwise.  */
 979                 if (maxsize != -1
 980                     && csize && host_integerp (csize, 1))
 981                   {
 982                     maxsize = (TREE_INT_CST_LOW (csize)
 983                                - TREE_INT_CST_LOW (bit_offset));
 984                   }
 985                 else
 986                   maxsize = -1;
 987               }
 988           }
 989           break;
 990
 991         case ARRAY_REF:
 992         case ARRAY_RANGE_REF:
 993           {
 994             tree index = TREE_OPERAND (exp, 1);
 995             tree low_bound = array_ref_low_bound (exp);
 996             tree unit_size = array_ref_element_size (exp);
 997
 998             if (! integer_zerop (low_bound))
 999               index = fold_build2 (MINUS_EXPR, TREE_TYPE (index),
1000                                    index, low_bound);
1001             index = size_binop (MULT_EXPR,
1002                                 fold_convert (sizetype, index), unit_size);
1003             if (TREE_CODE (index) == INTEGER_CST)
1004               {
1005                 index = size_binop (MULT_EXPR,
1006                                     fold_convert (bitsizetype, index),
1007                                     bitsize_unit_node);
1008                 bit_offset = size_binop (PLUS_EXPR, bit_offset, index);
1009
1010                 /* An array ref with a constant index up in the structure
1011                    hierarchy will constrain the size of any variable array ref
1012                    lower in the access hierarchy.  */
1013                 seen_variable_array_ref = false;
1014               }
1015             else
1016               {
1017                 tree asize = TYPE_SIZE (TREE_TYPE (TREE_OPERAND (exp, 0)));
1018                 /* We need to adjust maxsize to the whole array bitsize.
1019                    But we can subtract any constant offset seen sofar,
1020                    because that would get us outside of the array otherwise.  */
1021                 if (maxsize != -1
1022                     && asize && host_integerp (asize, 1))
1023                   {
1024                     maxsize = (TREE_INT_CST_LOW (asize)
1025                                - TREE_INT_CST_LOW (bit_offset));
1026                   }
1027                 else
1028                   maxsize = -1;
1029
1030                 /* Remember that we have seen an array ref with a variable
1031                    index.  */
1032                 seen_variable_array_ref = true;
1033               }
1034           }
1035           break;
1036
1037         case REALPART_EXPR:
1038           break;
1039
1040         case IMAGPART_EXPR:
1041           bit_offset = size_binop (PLUS_EXPR, bit_offset,
1042                                    bitsize_int (bitsize));
1043           break;
1044
1045         case VIEW_CONVERT_EXPR:
1046           /* ???  We probably should give up here and bail out.  */
1047           break;
1048
1049         default:
1050           goto done;
1051         }
1052
1053       exp = TREE_OPERAND (exp, 0);
1054     }
1055  done:
1056
1057   /* We need to deal with variable arrays ending structures such as
1058        struct { int length; int a[1]; } x;           x.a[d]
1059        struct { struct { int a; int b; } a[1]; } x;  x.a[d].a
1060        struct { struct { int a[1]; } a[1]; } x;      x.a[0][d], x.a[d][0]
1061      where we do not know maxsize for variable index accesses to
1062      the array.  The simplest way to conservatively deal with this
1063      is to punt in the case that offset + maxsize reaches the
1064      base type boundary.  */
1065   if (seen_variable_array_ref
1066       && maxsize != -1
1067       && host_integerp (TYPE_SIZE (TREE_TYPE (exp)), 1)
1068       && TREE_INT_CST_LOW (bit_offset) + maxsize
1069          == TREE_INT_CST_LOW (TYPE_SIZE (TREE_TYPE (exp))))
1070     maxsize = -1;
1071
1072   /* ???  Due to negative offsets in ARRAY_REF we can end up with
1073      negative bit_offset here.  We might want to store a zero offset
1074      in this case.  */
1075   *poffset = TREE_INT_CST_LOW (bit_offset);
1076   *psize = bitsize;
1077   *pmax_size = maxsize;
1078
1079   return exp;
1080 }