OSDN Git Service

PR fortran/30964
[pf3gnuchains/gcc-fork.git] / gcc / tree-dfa.c
index 0fa9b2c..7832b68 100644 (file)
@@ -1,12 +1,12 @@
 /* Data flow functions for trees.
-   Copyright (C) 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
+   Copyright (C) 2001, 2002, 2003, 2004, 2005, 2007 Free Software Foundation, Inc.
    Contributed by Diego Novillo <dnovillo@redhat.com>
 
 This file is part of GCC.
 
 GCC is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2, or (at your option)
+the Free Software Foundation; either version 3, or (at your option)
 any later version.
 
 GCC is distributed in the hope that it will be useful,
@@ -15,9 +15,8 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
-along with GCC; see the file COPYING.  If not, write to
-the Free Software Foundation, 51 Franklin Street, Fifth Floor,
-Boston, MA 02110-1301, USA.  */
+along with GCC; see the file COPYING3.  If not see
+<http://www.gnu.org/licenses/>.  */
 
 #include "config.h"
 #include "system.h"
@@ -59,17 +58,8 @@ struct dfa_stats_d
   long num_phis;
   long num_phi_args;
   int max_num_phi_args;
-  long num_v_may_defs;
+  long num_vdefs;
   long num_vuses;
-  long num_v_must_defs;
-};
-
-
-/* State information for find_vars_r.  */
-struct walk_state
-{
-  /* Hash table used to avoid adding the same variable more than once.  */
-  htab_t vars_found;
 };
 
 
@@ -77,13 +67,6 @@ struct walk_state
 static void collect_dfa_stats (struct dfa_stats_d *);
 static tree collect_dfa_stats_r (tree *, int *, void *);
 static tree find_vars_r (tree *, int *, void *);
-static void add_referenced_var (tree, struct walk_state *);
-
-
-/* Global declarations.  */
-
-/* Array of all variables referenced in the function.  */
-VEC(tree,gc) *referenced_vars;
 
 
 /*---------------------------------------------------------------------------
@@ -97,26 +80,20 @@ VEC(tree,gc) *referenced_vars;
    various attributes for each variable used by alias analysis and the
    optimizer.  */
 
-static void
+static unsigned int
 find_referenced_vars (void)
 {
-  htab_t vars_found;
   basic_block bb;
   block_stmt_iterator si;
-  struct walk_state walk_state;
-
-  vars_found = htab_create (50, htab_hash_pointer, htab_eq_pointer, NULL);
-  memset (&walk_state, 0, sizeof (walk_state));
-  walk_state.vars_found = vars_found;
 
   FOR_EACH_BB (bb)
     for (si = bsi_start (bb); !bsi_end_p (si); bsi_next (&si))
       {
        tree *stmt_p = bsi_stmt_ptr (si);
-       walk_tree (stmt_p, find_vars_r, &walk_state, NULL);
+       walk_tree (stmt_p, find_vars_r, NULL, NULL);
       }
 
-  htab_delete (vars_found);
+  return 0;
 }
 
 struct tree_opt_pass pass_referenced_vars =
@@ -146,21 +123,57 @@ var_ann_t
 create_var_ann (tree t)
 {
   var_ann_t ann;
+  struct static_var_ann_d *sann = NULL;
 
   gcc_assert (t);
   gcc_assert (DECL_P (t));
-  gcc_assert (!t->common.ann || t->common.ann->common.type == VAR_ANN);
+  gcc_assert (!t->base.ann || t->base.ann->common.type == VAR_ANN);
 
-  ann = ggc_alloc (sizeof (*ann));
-  memset ((void *) ann, 0, sizeof (*ann));
+  if (!MTAG_P (t) && (TREE_STATIC (t) || DECL_EXTERNAL (t)))
+    {
+      sann = GGC_CNEW (struct static_var_ann_d);
+      ann = &sann->ann;
+    }
+  else
+    ann = GGC_CNEW (struct var_ann_d);
 
   ann->common.type = VAR_ANN;
 
-  t->common.ann = (tree_ann_t) ann;
+  if (!MTAG_P (t) && (TREE_STATIC (t) || DECL_EXTERNAL (t)))
+    {
+       void **slot;
+       sann->uid = DECL_UID (t);
+       slot = htab_find_slot_with_hash (gimple_var_anns (cfun),
+                                       t, DECL_UID (t), INSERT);
+       gcc_assert (!*slot);
+       *slot = sann;
+    }
+  else
+    t->base.ann = (tree_ann_t) ann;
 
   return ann;
 }
 
+/* Create a new annotation for a FUNCTION_DECL node T.  */
+
+function_ann_t
+create_function_ann (tree t)
+{
+  function_ann_t ann;
+
+  gcc_assert (t);
+  gcc_assert (TREE_CODE (t) == FUNCTION_DECL);
+  gcc_assert (!t->base.ann || t->base.ann->common.type == FUNCTION_ANN);
+
+  ann = ggc_alloc (sizeof (*ann));
+  memset ((void *) ann, 0, sizeof (*ann));
+
+  ann->common.type = FUNCTION_ANN;
+
+  t->base.ann = (tree_ann_t) ann;
+
+  return ann;
+}
 
 /* Create a new annotation for a statement node T.  */
 
@@ -170,36 +183,34 @@ create_stmt_ann (tree t)
   stmt_ann_t ann;
 
   gcc_assert (is_gimple_stmt (t));
-  gcc_assert (!t->common.ann || t->common.ann->common.type == STMT_ANN);
+  gcc_assert (!t->base.ann || t->base.ann->common.type == STMT_ANN);
 
-  ann = ggc_alloc (sizeof (*ann));
-  memset ((void *) ann, 0, sizeof (*ann));
+  ann = GGC_CNEW (struct stmt_ann_d);
 
   ann->common.type = STMT_ANN;
 
   /* Since we just created the annotation, mark the statement modified.  */
   ann->modified = true;
 
-  t->common.ann = (tree_ann_t) ann;
+  t->base.ann = (tree_ann_t) ann;
 
   return ann;
 }
 
 /* Create a new annotation for a tree T.  */
 
-tree_ann_t
-create_tree_ann (tree t)
+tree_ann_common_t
+create_tree_common_ann (tree t)
 {
-  tree_ann_t ann;
+  tree_ann_common_t ann;
 
   gcc_assert (t);
-  gcc_assert (!t->common.ann || t->common.ann->common.type == TREE_ANN_COMMON);
+  gcc_assert (!t->base.ann || t->base.ann->common.type == TREE_ANN_COMMON);
 
-  ann = ggc_alloc (sizeof (*ann));
-  memset ((void *) ann, 0, sizeof (*ann));
+  ann = GGC_CNEW (struct tree_ann_common_d);
 
-  ann->common.type = TREE_ANN_COMMON;
-  t->common.ann = ann;
+  ann->type = TREE_ANN_COMMON;
+  t->base.ann = (tree_ann_t) ann;
 
   return ann;
 }
@@ -210,9 +221,14 @@ tree
 make_rename_temp (tree type, const char *prefix)
 {
   tree t = create_tmp_var (type, prefix);
-  if (referenced_vars)
+
+  if (TREE_CODE (TREE_TYPE (t)) == COMPLEX_TYPE
+      || TREE_CODE (TREE_TYPE (t)) == VECTOR_TYPE)
+    DECL_GIMPLE_REG_P (t) = 1;
+
+  if (gimple_referenced_vars (cfun))
     {
-      add_referenced_tmp_var (t);
+      add_referenced_var (t);
       mark_sym_for_renaming (t);
     }
 
@@ -230,14 +246,14 @@ make_rename_temp (tree type, const char *prefix)
 void
 dump_referenced_vars (FILE *file)
 {
-  size_t i;
-
+  tree var;
+  referenced_var_iterator rvi;
+  
   fprintf (file, "\nReferenced variables in %s: %u\n\n",
           get_name (current_function_decl), (unsigned) num_referenced_vars);
-
-  for (i = 0; i < num_referenced_vars; i++)
+  
+  FOR_EACH_REFERENCED_VAR (var, rvi)
     {
-      tree var = referenced_var (i);
       fprintf (file, "Variable: ");
       dump_variable (file, var);
       fprintf (file, "\n");
@@ -254,6 +270,37 @@ debug_referenced_vars (void)
 }
 
 
+/* Dump sub-variables for VAR to FILE.  */
+
+void
+dump_subvars_for (FILE *file, tree var)
+{
+  subvar_t sv = get_subvars_for_var (var);
+
+  if (!sv)
+    return;
+
+  fprintf (file, "{ ");
+
+  for (; sv; sv = sv->next)
+    {
+      print_generic_expr (file, sv->var, dump_flags);
+      fprintf (file, " ");
+    }
+
+  fprintf (file, "}");
+}
+
+
+/* Dumb sub-variables for VAR to stderr.  */
+
+void
+debug_subvars_for (tree var)
+{
+  dump_subvars_for (stderr, var);
+}
+
+
 /* Dump variable VAR and its may-aliases to FILE.  */
 
 void
@@ -278,20 +325,17 @@ dump_variable (FILE *file, tree var)
 
   ann = var_ann (var);
 
-  fprintf (file, ", UID %u", (unsigned) ann->uid);
+  fprintf (file, ", UID %u", (unsigned) DECL_UID (var));
 
   fprintf (file, ", ");
   print_generic_expr (file, TREE_TYPE (var), dump_flags);
 
-  if (ann->type_mem_tag)
+  if (ann && ann->symbol_mem_tag)
     {
-      fprintf (file, ", type memory tag: ");
-      print_generic_expr (file, ann->type_mem_tag, dump_flags);
+      fprintf (file, ", symbol memory tag: ");
+      print_generic_expr (file, ann->symbol_mem_tag, dump_flags);
     }
 
-  if (ann->is_alias_tag)
-    fprintf (file, ", is an alias tag");
-
   if (TREE_ADDRESSABLE (var))
     fprintf (file, ", is addressable");
   
@@ -301,21 +345,87 @@ dump_variable (FILE *file, tree var)
   if (TREE_THIS_VOLATILE (var))
     fprintf (file, ", is volatile");
 
+  if (mem_sym_stats (cfun, var))
+    {
+      mem_sym_stats_t stats = mem_sym_stats (cfun, var);
+      fprintf (file, ", direct reads: %ld", stats->num_direct_reads);
+      fprintf (file, ", direct writes: %ld", stats->num_direct_writes);
+      fprintf (file, ", indirect reads: %ld", stats->num_indirect_reads);
+      fprintf (file, ", indirect writes: %ld", stats->num_indirect_writes);
+      fprintf (file, ", read frequency: %ld", stats->frequency_reads);
+      fprintf (file, ", write frequency: %ld", stats->frequency_writes);
+    }
+
   if (is_call_clobbered (var))
-    fprintf (file, ", call clobbered");
+    {
+      const char *s = "";
+      var_ann_t va = var_ann (var);
+      unsigned int escape_mask = va->escape_mask;
+
+      fprintf (file, ", call clobbered");
+      fprintf (file, " (");
+      if (escape_mask & ESCAPE_STORED_IN_GLOBAL)
+       { fprintf (file, "%sstored in global", s); s = ", "; }
+      if (escape_mask & ESCAPE_TO_ASM)
+       { fprintf (file, "%sgoes through ASM", s); s = ", "; }
+      if (escape_mask & ESCAPE_TO_CALL)
+       { fprintf (file, "%spassed to call", s); s = ", "; }
+      if (escape_mask & ESCAPE_BAD_CAST)
+       { fprintf (file, "%sbad cast", s); s = ", "; }
+      if (escape_mask & ESCAPE_TO_RETURN)
+       { fprintf (file, "%sreturned from func", s); s = ", "; }
+      if (escape_mask & ESCAPE_TO_PURE_CONST)
+       { fprintf (file, "%spassed to pure/const", s); s = ", "; }
+      if (escape_mask & ESCAPE_IS_GLOBAL)
+       { fprintf (file, "%sis global var", s); s = ", "; }
+      if (escape_mask & ESCAPE_IS_PARM)
+       { fprintf (file, "%sis incoming pointer", s); s = ", "; }
+      if (escape_mask & ESCAPE_UNKNOWN)
+       { fprintf (file, "%sunknown escape", s); s = ", "; }
+      fprintf (file, ")");
+    }
+
+  if (ann->noalias_state == NO_ALIAS)
+    fprintf (file, ", NO_ALIAS (does not alias other NO_ALIAS symbols)");
+  else if (ann->noalias_state == NO_ALIAS_GLOBAL)
+    fprintf (file, ", NO_ALIAS_GLOBAL (does not alias other NO_ALIAS symbols"
+                  " and global vars)");
+  else if (ann->noalias_state == NO_ALIAS_ANYTHING)
+    fprintf (file, ", NO_ALIAS_ANYTHING (does not alias any other symbols)");
 
-  if (ann->default_def)
+  if (gimple_default_def (cfun, var))
     {
       fprintf (file, ", default def: ");
-      print_generic_expr (file, ann->default_def, dump_flags);
+      print_generic_expr (file, gimple_default_def (cfun, var), dump_flags);
     }
 
-  if (ann->may_aliases)
+  if (MTAG_P (var) && may_aliases (var))
     {
       fprintf (file, ", may aliases: ");
       dump_may_aliases_for (file, var);
     }
 
+  if (get_subvars_for_var (var))
+    {
+      fprintf (file, ", sub-vars: ");
+      dump_subvars_for (file, var);
+    }
+
+  if (!is_gimple_reg (var))
+    {
+      if (memory_partition (var))
+       {
+         fprintf (file, ", belongs to partition: ");
+         print_generic_expr (file, memory_partition (var), dump_flags);
+       }
+
+      if (TREE_CODE (var) == MEMORY_PARTITION_TAG)
+       {
+         fprintf (file, ", partition symbols: ");
+         dump_decl_set (file, MPT_SYMBOLS (var));
+       }
+    }
+
   fprintf (file, "\n");
 }
 
@@ -382,14 +492,9 @@ dump_dfa_stats (FILE *file)
   fprintf (file, fmt_str_1, "VUSE operands", dfa_stats.num_vuses,
           SCALE (size), LABEL (size));
 
-  size = dfa_stats.num_v_may_defs * sizeof (tree *);
-  total += size;
-  fprintf (file, fmt_str_1, "V_MAY_DEF operands", dfa_stats.num_v_may_defs,
-          SCALE (size), LABEL (size));
-
-  size = dfa_stats.num_v_must_defs * sizeof (tree *);
+  size = dfa_stats.num_vdefs * sizeof (tree *);
   total += size;
-  fprintf (file, fmt_str_1, "V_MUST_DEF operands", dfa_stats.num_v_must_defs,
+  fprintf (file, fmt_str_1, "VDEF operands", dfa_stats.num_vdefs,
           SCALE (size), LABEL (size));
 
   size = dfa_stats.num_phis * sizeof (struct tree_phi_node);
@@ -426,7 +531,7 @@ debug_dfa_stats (void)
 }
 
 
-/* Collect DFA statistics and store them in the structure pointed by
+/* Collect DFA statistics and store them in the structure pointed to by
    DFA_STATS_P.  */
 
 static void
@@ -441,10 +546,11 @@ collect_dfa_stats (struct dfa_stats_d *dfa_stats_p)
   memset ((void *)dfa_stats_p, 0, sizeof (struct dfa_stats_d));
 
   /* Walk all the trees in the function counting references.  Start at
-     basic block 0, but don't stop at block boundaries.  */
+     basic block NUM_FIXED_BLOCKS, but don't stop at block boundaries.  */
   pset = pointer_set_create ();
 
-  for (i = bsi_start (BASIC_BLOCK (0)); !bsi_end_p (i); bsi_next (&i))
+  for (i = bsi_start (BASIC_BLOCK (NUM_FIXED_BLOCKS));
+       !bsi_end_p (i); bsi_next (&i))
     walk_tree (bsi_stmt_ptr (i), collect_dfa_stats_r, (void *) dfa_stats_p,
               pset);
 
@@ -474,19 +580,17 @@ collect_dfa_stats_r (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED,
   tree t = *tp;
   struct dfa_stats_d *dfa_stats_p = (struct dfa_stats_d *)data;
 
-  if (t->common.ann)
+  if (t->base.ann)
     {
-      switch (ann_type (t->common.ann))
+      switch (ann_type (t->base.ann))
        {
        case STMT_ANN:
          {
            dfa_stats_p->num_stmt_anns++;
            dfa_stats_p->num_defs += NUM_SSA_OPERANDS (t, SSA_OP_DEF);
            dfa_stats_p->num_uses += NUM_SSA_OPERANDS (t, SSA_OP_USE);
-           dfa_stats_p->num_v_may_defs += NUM_SSA_OPERANDS (t, SSA_OP_VMAYDEF);
+           dfa_stats_p->num_vdefs += NUM_SSA_OPERANDS (t, SSA_OP_VDEF);
            dfa_stats_p->num_vuses += NUM_SSA_OPERANDS (t, SSA_OP_VUSE);
-           dfa_stats_p->num_v_must_defs += 
-                                 NUM_SSA_OPERANDS (t, SSA_OP_VMUSTDEF);
            break;
          }
 
@@ -510,14 +614,12 @@ collect_dfa_stats_r (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED,
    the function.  */
 
 static tree
-find_vars_r (tree *tp, int *walk_subtrees, void *data)
+find_vars_r (tree *tp, int *walk_subtrees, void *data ATTRIBUTE_UNUSED)
 {
-  struct walk_state *walk_state = (struct walk_state *) data;
-
   /* If T is a regular variable that the optimizers are interested
      in, add it to the list of variables.  */
   if (SSA_VAR_P (*tp))
-    add_referenced_var (*tp, walk_state);
+    add_referenced_var (*tp);
 
   /* Type, _DECL and constant nodes have no interesting children.
      Ignore them.  */
@@ -527,56 +629,168 @@ find_vars_r (tree *tp, int *walk_subtrees, void *data)
   return NULL_TREE;
 }
 
+/* Lookup UID in the referenced_vars hashtable and return the associated
+   variable.  */
 
-/* Add VAR to the list of dereferenced variables.
+tree 
+referenced_var_lookup (unsigned int uid)
+{
+  struct int_tree_map *h, in;
+  in.uid = uid;
+  h = (struct int_tree_map *)
+       htab_find_with_hash (gimple_referenced_vars (cfun), &in, uid);
+  gcc_assert (h || uid == 0);
+  if (h)
+    return h->to;
+  return NULL_TREE;
+}
 
-   WALK_STATE contains a hash table used to avoid adding the same
-      variable more than once. Note that this function assumes that
-      VAR is a valid SSA variable.  If WALK_STATE is NULL, no
-      duplicate checking is done.  */
+/* Check if TO is in the referenced_vars hash table and insert it if not.  
+   Return true if it required insertion.  */
 
-static void
-add_referenced_var (tree var, struct walk_state *walk_state)
+bool
+referenced_var_check_and_insert (tree to)
+{ 
+  struct int_tree_map *h, in;
+  void **loc;
+  unsigned int uid = DECL_UID (to);
+
+  in.uid = uid;
+  in.to = to;
+  h = (struct int_tree_map *) htab_find_with_hash (gimple_referenced_vars (cfun),
+                                                  &in, uid);
+
+  if (h)
+    {
+      /* DECL_UID has already been entered in the table.  Verify that it is
+        the same entry as TO.  See PR 27793.  */
+      gcc_assert (h->to == to);
+      return false;
+    }
+
+  h = GGC_NEW (struct int_tree_map);
+  h->uid = uid;
+  h->to = to;
+  loc = htab_find_slot_with_hash (gimple_referenced_vars (cfun),
+                                 h, uid, INSERT);
+  *(struct int_tree_map **)  loc = h;
+  return true;
+}
+
+/* Lookup VAR UID in the default_defs hashtable and return the associated
+   variable.  */
+
+tree 
+gimple_default_def (struct function *fn, tree var)
 {
-  void **slot;
-  var_ann_t v_ann;
+  struct int_tree_map *h, in;
+  gcc_assert (SSA_VAR_P (var));
+  in.uid = DECL_UID (var);
+  h = (struct int_tree_map *) htab_find_with_hash (DEFAULT_DEFS (fn),
+                                                  &in,
+                                                   DECL_UID (var));
+  if (h)
+    return h->to;
+  return NULL_TREE;
+}
 
-  v_ann = get_var_ann (var);
+/* Insert the pair VAR's UID, DEF into the default_defs hashtable.  */
 
-  if (walk_state)
-    slot = htab_find_slot (walk_state->vars_found, (void *) var, INSERT);
-  else
-    slot = NULL;
+void
+set_default_def (tree var, tree def)
+{ 
+  struct int_tree_map in;
+  struct int_tree_map *h;
+  void **loc;
+
+  gcc_assert (SSA_VAR_P (var));
+  in.uid = DECL_UID (var);
+  if (!def && gimple_default_def (cfun, var))
+    {
+      loc = htab_find_slot_with_hash (DEFAULT_DEFS (cfun), &in,
+            DECL_UID (var), INSERT);
+      htab_remove_elt (DEFAULT_DEFS (cfun), *loc);
+      return;
+    }
+  gcc_assert (!def || TREE_CODE (def) == SSA_NAME);
+  loc = htab_find_slot_with_hash (DEFAULT_DEFS (cfun), &in,
+                                  DECL_UID (var), INSERT);
+
+  /* Default definition might be changed by tail call optimization.  */
+  if (!*loc)
+    {
+      h = GGC_NEW (struct int_tree_map);
+      h->uid = DECL_UID (var);
+      h->to = def;
+      *(struct int_tree_map **)  loc = h;
+    }
+   else
+    {
+      h = (struct int_tree_map *) *loc;
+      SSA_NAME_IS_DEFAULT_DEF (h->to) = false;
+      h->to = def;
+    }
+
+   /* Mark DEF as the default definition for VAR.  */
+   SSA_NAME_IS_DEFAULT_DEF (def) = true;
+}
+
+/* Add VAR to the list of referenced variables if it isn't already there.  */
+
+void
+add_referenced_var (tree var)
+{
+  var_ann_t v_ann;
 
-  if (slot == NULL || *slot == NULL)
+  v_ann = get_var_ann (var);
+  gcc_assert (DECL_P (var));
+  
+  /* Insert VAR into the referenced_vars has table if it isn't present.  */
+  if (referenced_var_check_and_insert (var))
     {
-      /* This is the first time we find this variable, add it to the
-         REFERENCED_VARS array and annotate it with attributes that are
-        intrinsic to the variable.  */
-      if (slot)
-       *slot = (void *) var;
-      v_ann->uid = num_referenced_vars;
-      VEC_safe_push (tree, gc, referenced_vars, var);
-
-      /* Global variables are always call-clobbered.  */
-      if (is_global_var (var))
-       mark_call_clobbered (var);
+      /* This is the first time we found this variable, annotate it with
+        attributes that are intrinsic to the variable.  */
+      
+      /* Tag's don't have DECL_INITIAL.  */
+      if (MTAG_P (var))
+       return;
 
       /* Scan DECL_INITIAL for pointer variables as they may contain
         address arithmetic referencing the address of other
-        variables.  */
+        variables.  
+        Even non-constant intializers need to be walked, because
+        IPA passes might prove that their are invariant later on.  */
       if (DECL_INITIAL (var)
          /* Initializers of external variables are not useful to the
             optimizers.  */
-          && !DECL_EXTERNAL (var)
-         /* It's not necessary to walk the initial value of non-constant
-            public variables because it cannot be propagated by the
-            optimizers.  */
-         && (!TREE_PUBLIC (var) || !TREE_CONSTANT (var)))
-       walk_tree (&DECL_INITIAL (var), find_vars_r, walk_state, 0);
+          && !DECL_EXTERNAL (var))
+       walk_tree (&DECL_INITIAL (var), find_vars_r, NULL, 0);
     }
 }
 
+/* Remove VAR from the list.  */
+
+void
+remove_referenced_var (tree var)
+{
+  var_ann_t v_ann;
+  struct int_tree_map in;
+  void **loc;
+  unsigned int uid = DECL_UID (var);
+
+  clear_call_clobbered (var);
+  v_ann = get_var_ann (var);
+  ggc_free (v_ann);
+  var->base.ann = NULL;
+  gcc_assert (DECL_P (var));
+  in.uid = uid;
+  in.to = var;
+  loc = htab_find_slot_with_hash (gimple_referenced_vars (cfun), &in, uid,
+                                 NO_INSERT);
+  ggc_free (*loc);
+  htab_clear_slot (gimple_referenced_vars (cfun), loc);
+}
+
 
 /* Return the virtual variable associated to the non-scalar variable VAR.  */
 
@@ -601,81 +815,27 @@ get_virtual_var (tree var)
   return var;
 }
 
-/* Add a temporary variable to REFERENCED_VARS.  This is similar to
-   add_referenced_var, but is used by passes that need to add new temps to
-   the REFERENCED_VARS array after the program has been scanned for
-   variables.  The variable will just receive a new UID and be added
-   to the REFERENCED_VARS array without checking for duplicates.  */
-
-void
-add_referenced_tmp_var (tree var)
-{
-  add_referenced_var (var, NULL);
-}
-
-
-/* Mark all the non-SSA variables found in STMT's operands to be
-   processed by update_ssa.  */
+/* Mark all the naked symbols in STMT for SSA renaming.
+   
+   NOTE: This function should only be used for brand new statements.
+   If the caller is modifying an existing statement, it should use the
+   combination push_stmt_changes/pop_stmt_changes.  */
 
 void
-mark_new_vars_to_rename (tree stmt)
+mark_symbols_for_renaming (tree stmt)
 {
+  tree op;
   ssa_op_iter iter;
-  tree val;
-  bitmap vars_in_vops_to_rename;
-  bool found_exposed_symbol = false;
-  int v_may_defs_before, v_may_defs_after;
-  int v_must_defs_before, v_must_defs_after;
-
-  vars_in_vops_to_rename = BITMAP_ALLOC (NULL);
-
-  /* Before re-scanning the statement for operands, mark the existing
-     virtual operands to be renamed again.  We do this because when new
-     symbols are exposed, the virtual operands that were here before due to
-     aliasing will probably be removed by the call to get_stmt_operand.
-     Therefore, we need to flag them to be renamed beforehand.
-
-     We flag them in a separate bitmap because we don't really want to
-     rename them if there are not any newly exposed symbols in the
-     statement operands.  */
-  v_may_defs_before = NUM_SSA_OPERANDS (stmt, SSA_OP_VMAYDEF);
-  v_must_defs_before = NUM_SSA_OPERANDS (stmt, SSA_OP_VMUSTDEF);
-
-  FOR_EACH_SSA_TREE_OPERAND (val, stmt, iter, 
-                            SSA_OP_VMAYDEF | SSA_OP_VUSE | SSA_OP_VMUSTDEF)
-    {
-      if (!DECL_P (val))
-       val = SSA_NAME_VAR (val);
-      bitmap_set_bit (vars_in_vops_to_rename, var_ann (val)->uid);
-    }
 
-  /* Now force an operand re-scan on the statement and mark any newly
-     exposed variables.  */
   update_stmt (stmt);
 
-  v_may_defs_after = NUM_SSA_OPERANDS (stmt, SSA_OP_VMAYDEF);
-  v_must_defs_after = NUM_SSA_OPERANDS (stmt, SSA_OP_VMUSTDEF);
-
-  FOR_EACH_SSA_TREE_OPERAND (val, stmt, iter, SSA_OP_ALL_OPERANDS)
-    if (DECL_P (val))
-      {
-       found_exposed_symbol = true;
-       mark_sym_for_renaming (val);
-      }
-
-  /* If we found any newly exposed symbols, or if there are fewer VDEF
-     operands in the statement, add the variables we had set in
-     VARS_IN_VOPS_TO_RENAME to VARS_TO_RENAME.  We need to check for
-     vanishing VDEFs because in those cases, the names that were formerly
-     generated by this statement are not going to be available anymore.  */
-  if (found_exposed_symbol
-      || v_may_defs_before > v_may_defs_after
-      || v_must_defs_before > v_must_defs_after)
-    mark_set_for_renaming (vars_in_vops_to_rename);
-
-  BITMAP_FREE (vars_in_vops_to_rename);
+  /* Mark all the operands for renaming.  */
+  FOR_EACH_SSA_TREE_OPERAND (op, stmt, iter, SSA_OP_ALL_OPERANDS)
+    if (DECL_P (op))
+      mark_sym_for_renaming (op);
 }
 
+
 /* Find all variables within the gimplified statement that were not previously
    visible to the function and add them to the referenced variables list.  */
 
@@ -687,7 +847,7 @@ find_new_referenced_vars_1 (tree *tp, int *walk_subtrees,
 
   if (TREE_CODE (t) == VAR_DECL && !var_ann (t))
     {
-      add_referenced_tmp_var (t);
+      add_referenced_var (t);
       mark_sym_for_renaming (t);
     }
 
@@ -704,45 +864,192 @@ find_new_referenced_vars (tree *stmt_p)
 }
 
 
-/* If REF is a COMPONENT_REF for a structure that can have sub-variables, and
-   we know where REF is accessing, return the variable in REF that has the
-   sub-variables.  If the return value is not NULL, POFFSET will be the
-   offset, in bits, of REF inside the return value, and PSIZE will be the
-   size, in bits, of REF inside the return value.  */
+/* If EXP is a handled component reference for a structure, return the
+   base variable.  The access range is delimited by bit positions *POFFSET and
+   *POFFSET + *PMAX_SIZE.  The access size is *PSIZE bits.  If either
+   *PSIZE or *PMAX_SIZE is -1, they could not be determined.  If *PSIZE
+   and *PMAX_SIZE are equal, the access is non-variable.  */
 
 tree
-okay_component_ref_for_subvars (tree ref, HOST_WIDE_INT *poffset,
-                               HOST_WIDE_INT *psize)
+get_ref_base_and_extent (tree exp, HOST_WIDE_INT *poffset,
+                        HOST_WIDE_INT *psize,
+                        HOST_WIDE_INT *pmax_size)
 {
-  tree result = NULL;
-  HOST_WIDE_INT bitsize;
-  HOST_WIDE_INT bitpos;
-  tree offset;
-  enum machine_mode mode;
-  int unsignedp;
-  int volatilep;
-
-  gcc_assert (!SSA_VAR_P (ref));
-  *poffset = 0;  
-  *psize = (unsigned int) -1;
-  
-  if (ref_contains_array_ref (ref))
-    return result;
-  ref = get_inner_reference (ref, &bitsize, &bitpos, &offset, &mode,
-                            &unsignedp, &volatilep, false);
-  if (TREE_CODE (ref) == INDIRECT_REF)
-    return result;
-  else if (offset == NULL && bitsize != -1 && SSA_VAR_P (ref))
+  HOST_WIDE_INT bitsize = -1;
+  HOST_WIDE_INT maxsize = -1;
+  tree size_tree = NULL_TREE;
+  HOST_WIDE_INT bit_offset = 0;
+  bool seen_variable_array_ref = false;
+
+  gcc_assert (!SSA_VAR_P (exp));
+
+  /* First get the final access size from just the outermost expression.  */
+  if (TREE_CODE (exp) == COMPONENT_REF)
+    size_tree = DECL_SIZE (TREE_OPERAND (exp, 1));
+  else if (TREE_CODE (exp) == BIT_FIELD_REF)
+    size_tree = TREE_OPERAND (exp, 1);
+  else
     {
-      *poffset = bitpos;      
-      *psize = bitsize;
-      if (get_subvars_for_var (ref) != NULL)
-       return ref;
+      enum machine_mode mode = TYPE_MODE (TREE_TYPE (exp));
+      if (mode == BLKmode)
+       size_tree = TYPE_SIZE (TREE_TYPE (exp));
+      else
+       bitsize = GET_MODE_BITSIZE (mode);
     }
-  else if (SSA_VAR_P (ref))
+  if (size_tree != NULL_TREE)
     {
-      if (get_subvars_for_var (ref) != NULL)
-       return ref;
+      if (! host_integerp (size_tree, 1))
+       bitsize = -1;
+      else
+       bitsize = TREE_INT_CST_LOW (size_tree);
     }
-  return NULL_TREE;
+
+  /* Initially, maxsize is the same as the accessed element size.
+     In the following it will only grow (or become -1).  */
+  maxsize = bitsize;
+
+  /* Compute cumulative bit-offset for nested component-refs and array-refs,
+     and find the ultimate containing object.  */
+  while (1)
+    {
+      switch (TREE_CODE (exp))
+       {
+       case BIT_FIELD_REF:
+         bit_offset += tree_low_cst (TREE_OPERAND (exp, 2), 0);
+         break;
+
+       case COMPONENT_REF:
+         {
+           tree field = TREE_OPERAND (exp, 1);
+           tree this_offset = component_ref_field_offset (exp);
+
+           if (this_offset && TREE_CODE (this_offset) == INTEGER_CST)
+             {
+               HOST_WIDE_INT hthis_offset = tree_low_cst (this_offset, 0);
+
+               hthis_offset *= BITS_PER_UNIT;
+               bit_offset += hthis_offset;
+               bit_offset += tree_low_cst (DECL_FIELD_BIT_OFFSET (field), 0);
+             }
+           else
+             {
+               tree csize = TYPE_SIZE (TREE_TYPE (TREE_OPERAND (exp, 0)));
+               /* We need to adjust maxsize to the whole structure bitsize.
+                  But we can subtract any constant offset seen sofar,
+                  because that would get us out of the structure otherwise.  */
+               if (maxsize != -1 && csize && host_integerp (csize, 1))
+                 maxsize = TREE_INT_CST_LOW (csize) - bit_offset;
+               else
+                 maxsize = -1;
+             }
+         }
+         break;
+
+       case ARRAY_REF:
+       case ARRAY_RANGE_REF:
+         {
+           tree index = TREE_OPERAND (exp, 1);
+           tree low_bound = array_ref_low_bound (exp);
+           tree unit_size = array_ref_element_size (exp);
+
+           /* If the resulting bit-offset is constant, track it.  */
+           if (host_integerp (index, 0)
+               && host_integerp (low_bound, 0)
+               && host_integerp (unit_size, 1))
+             {
+               HOST_WIDE_INT hindex = tree_low_cst (index, 0);
+
+               hindex -= tree_low_cst (low_bound, 0);
+               hindex *= tree_low_cst (unit_size, 1);
+               hindex *= BITS_PER_UNIT;
+               bit_offset += hindex;
+
+               /* An array ref with a constant index up in the structure
+                  hierarchy will constrain the size of any variable array ref
+                  lower in the access hierarchy.  */
+               seen_variable_array_ref = false;
+             }
+           else
+             {
+               tree asize = TYPE_SIZE (TREE_TYPE (TREE_OPERAND (exp, 0)));
+               /* We need to adjust maxsize to the whole array bitsize.
+                  But we can subtract any constant offset seen sofar,
+                  because that would get us outside of the array otherwise.  */
+               if (maxsize != -1 && asize && host_integerp (asize, 1))
+                 maxsize = TREE_INT_CST_LOW (asize) - bit_offset;
+               else
+                 maxsize = -1;
+
+               /* Remember that we have seen an array ref with a variable
+                  index.  */
+               seen_variable_array_ref = true;
+             }
+         }
+         break;
+
+       case REALPART_EXPR:
+         break;
+
+       case IMAGPART_EXPR:
+         bit_offset += bitsize;
+         break;
+
+       case VIEW_CONVERT_EXPR:
+         /* ???  We probably should give up here and bail out.  */
+         break;
+
+       default:
+         goto done;
+       }
+
+      exp = TREE_OPERAND (exp, 0);
+    }
+ done:
+
+  /* We need to deal with variable arrays ending structures such as
+       struct { int length; int a[1]; } x;           x.a[d]
+       struct { struct { int a; int b; } a[1]; } x;  x.a[d].a
+       struct { struct { int a[1]; } a[1]; } x;      x.a[0][d], x.a[d][0]
+     where we do not know maxsize for variable index accesses to
+     the array.  The simplest way to conservatively deal with this
+     is to punt in the case that offset + maxsize reaches the
+     base type boundary.  */
+  if (seen_variable_array_ref
+      && maxsize != -1
+      && host_integerp (TYPE_SIZE (TREE_TYPE (exp)), 1)
+      && bit_offset + maxsize
+          == (signed)TREE_INT_CST_LOW (TYPE_SIZE (TREE_TYPE (exp))))
+    maxsize = -1;
+
+  /* ???  Due to negative offsets in ARRAY_REF we can end up with
+     negative bit_offset here.  We might want to store a zero offset
+     in this case.  */
+  *poffset = bit_offset;
+  *psize = bitsize;
+  *pmax_size = maxsize;
+
+  return exp;
+}
+
+
+/* Return memory reference statistics for variable VAR in function FN.
+   This is computed by alias analysis, but it is not kept
+   incrementally up-to-date.  So, these stats are only accurate if
+   pass_may_alias has been run recently.  If no alias information
+   exists, this function returns NULL.  */
+
+mem_sym_stats_t
+mem_sym_stats (struct function *fn, tree var)
+{
+  void **slot;
+  struct pointer_map_t *stats_map = gimple_mem_ref_stats (fn)->mem_sym_stats;
+
+  if (stats_map == NULL)
+    return NULL;
+
+  slot = pointer_map_contains (stats_map, var);
+  if (slot == NULL)
+    return NULL;
+
+  return (mem_sym_stats_t) *slot;
 }