diff gcc/tree-dfa.c @ 16:04ced10e8804

gcc 7
author kono
date Fri, 27 Oct 2017 22:46:09 +0900
parents f6334be47118
children 84e7813d76e9
line wrap: on
line diff
--- a/gcc/tree-dfa.c	Sun Aug 21 07:07:55 2011 +0900
+++ b/gcc/tree-dfa.c	Fri Oct 27 22:46:09 2017 +0900
@@ -1,6 +1,5 @@
 /* Data flow functions for trees.
-   Copyright (C) 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009, 2010
-   Free Software Foundation, Inc.
+   Copyright (C) 2001-2017 Free Software Foundation, Inc.
    Contributed by Diego Novillo <dnovillo@redhat.com>
 
 This file is part of GCC.
@@ -22,34 +21,25 @@
 #include "config.h"
 #include "system.h"
 #include "coretypes.h"
-#include "tm.h"
-#include "hashtab.h"
-#include "pointer-set.h"
+#include "backend.h"
+#include "rtl.h"
 #include "tree.h"
-#include "tm_p.h"
-#include "basic-block.h"
-#include "output.h"
-#include "timevar.h"
-#include "ggc.h"
+#include "gimple.h"
+#include "tree-pass.h"
+#include "ssa.h"
+#include "tree-pretty-print.h"
+#include "fold-const.h"
+#include "stor-layout.h"
 #include "langhooks.h"
-#include "flags.h"
-#include "function.h"
-#include "tree-pretty-print.h"
-#include "tree-dump.h"
-#include "gimple.h"
-#include "tree-flow.h"
-#include "tree-inline.h"
-#include "tree-pass.h"
-#include "convert.h"
-#include "params.h"
-#include "cgraph.h"
+#include "gimple-iterator.h"
+#include "gimple-walk.h"
+#include "tree-dfa.h"
 
 /* Build and maintain data flow information for trees.  */
 
 /* Counters used to display DFA and SSA statistics.  */
 struct dfa_stats_d
 {
-  long num_var_anns;
   long num_defs;
   long num_uses;
   long num_phis;
@@ -62,83 +52,11 @@
 
 /* Local functions.  */
 static void collect_dfa_stats (struct dfa_stats_d *);
-static tree find_vars_r (tree *, int *, void *);
 
 
 /*---------------------------------------------------------------------------
 			Dataflow analysis (DFA) routines
 ---------------------------------------------------------------------------*/
-/* Find all the variables referenced in the function.  This function
-   builds the global arrays REFERENCED_VARS and CALL_CLOBBERED_VARS.
-
-   Note that this function does not look for statement operands, it simply
-   determines what variables are referenced in the program and detects
-   various attributes for each variable used by alias analysis and the
-   optimizer.  */
-
-static unsigned int
-find_referenced_vars (void)
-{
-  basic_block bb;
-  gimple_stmt_iterator si;
-
-  FOR_EACH_BB (bb)
-    {
-      for (si = gsi_start_bb (bb); !gsi_end_p (si); gsi_next (&si))
-	{
-	  gimple stmt = gsi_stmt (si);
-	  if (is_gimple_debug (stmt))
-	    continue;
-	  find_referenced_vars_in (gsi_stmt (si));
-	}
-
-      for (si = gsi_start_phis (bb); !gsi_end_p (si); gsi_next (&si))
-	find_referenced_vars_in (gsi_stmt (si));
-    }
-
-  return 0;
-}
-
-struct gimple_opt_pass pass_referenced_vars =
-{
- {
-  GIMPLE_PASS,
-  "*referenced_vars",			/* name */
-  NULL,					/* gate */
-  find_referenced_vars,			/* execute */
-  NULL,					/* sub */
-  NULL,					/* next */
-  0,					/* static_pass_number */
-  TV_FIND_REFERENCED_VARS,		/* tv_id */
-  PROP_gimple_leh | PROP_cfg,		/* properties_required */
-  PROP_referenced_vars,			/* properties_provided */
-  0,					/* properties_destroyed */
-  TODO_dump_func,			/* todo_flags_start */
-  TODO_dump_func                        /* todo_flags_finish */
- }
-};
-
-
-/*---------------------------------------------------------------------------
-			    Manage annotations
----------------------------------------------------------------------------*/
-/* Create a new annotation for a _DECL node T.  */
-
-var_ann_t
-create_var_ann (tree t)
-{
-  var_ann_t ann;
-
-  gcc_assert (t);
-  gcc_assert (TREE_CODE (t) == VAR_DECL
-	      || TREE_CODE (t) == PARM_DECL
-	      || TREE_CODE (t) == RESULT_DECL);
-
-  ann = ggc_alloc_cleared_var_ann_d ();
-  *DECL_VAR_ANN_PTR (t) = ann;
-
-  return ann;
-}
 
 /* Renumber all of the gimple stmt uids.  */
 
@@ -148,12 +66,17 @@
   basic_block bb;
 
   set_gimple_stmt_max_uid (cfun, 0);
-  FOR_ALL_BB (bb)
+  FOR_ALL_BB_FN (bb, cfun)
     {
       gimple_stmt_iterator bsi;
+      for (bsi = gsi_start_phis (bb); !gsi_end_p (bsi); gsi_next (&bsi))
+	{
+	  gimple *stmt = gsi_stmt (bsi);
+	  gimple_set_uid (stmt, inc_gimple_stmt_max_uid (cfun));
+	}
       for (bsi = gsi_start_bb (bb); !gsi_end_p (bsi); gsi_next (&bsi))
 	{
-	  gimple stmt = gsi_stmt (bsi);
+	  gimple *stmt = gsi_stmt (bsi);
 	  gimple_set_uid (stmt, inc_gimple_stmt_max_uid (cfun));
 	}
     }
@@ -174,68 +97,22 @@
       gimple_stmt_iterator bsi;
       for (bsi = gsi_start_phis (bb); !gsi_end_p (bsi); gsi_next (&bsi))
 	{
-	  gimple stmt = gsi_stmt (bsi);
+	  gimple *stmt = gsi_stmt (bsi);
 	  gimple_set_uid (stmt, inc_gimple_stmt_max_uid (cfun));
 	}
       for (bsi = gsi_start_bb (bb); !gsi_end_p (bsi); gsi_next (&bsi))
 	{
-	  gimple stmt = gsi_stmt (bsi);
+	  gimple *stmt = gsi_stmt (bsi);
 	  gimple_set_uid (stmt, inc_gimple_stmt_max_uid (cfun));
 	}
     }
 }
 
-/* Build a temporary.  Make sure and register it to be renamed.  */
-
-tree
-make_rename_temp (tree type, const char *prefix)
-{
-  tree t = create_tmp_reg (type, prefix);
-
-  if (gimple_referenced_vars (cfun))
-    {
-      add_referenced_var (t);
-      mark_sym_for_renaming (t);
-    }
-
-  return t;
-}
-
 
 
 /*---------------------------------------------------------------------------
 			      Debugging functions
 ---------------------------------------------------------------------------*/
-/* Dump the list of all the referenced variables in the current function to
-   FILE.  */
-
-void
-dump_referenced_vars (FILE *file)
-{
-  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_EACH_REFERENCED_VAR (cfun, var, rvi)
-    {
-      fprintf (file, "Variable: ");
-      dump_variable (file, var);
-    }
-
-  fprintf (file, "\n");
-}
-
-
-/* Dump the list of all the referenced variables to stderr.  */
-
-DEBUG_FUNCTION void
-debug_referenced_vars (void)
-{
-  dump_referenced_vars (stderr);
-}
-
 
 /* Dump variable VAR and its may-aliases to FILE.  */
 
@@ -273,10 +150,10 @@
   if (TREE_THIS_VOLATILE (var))
     fprintf (file, ", is volatile");
 
-  if (cfun && gimple_default_def (cfun, var))
+  if (cfun && ssa_default_def (cfun, var))
     {
       fprintf (file, ", default def: ");
-      print_generic_expr (file, gimple_default_def (cfun, var), dump_flags);
+      print_generic_expr (file, ssa_default_def (cfun, var), dump_flags);
     }
 
   if (DECL_INITIAL (var))
@@ -321,16 +198,6 @@
   fprintf (file, fmt_str, "", "  instances  ", "used ");
   fprintf (file, "---------------------------------------------------------\n");
 
-  size = num_referenced_vars * sizeof (tree);
-  total += size;
-  fprintf (file, fmt_str_1, "Referenced variables", (unsigned long)num_referenced_vars,
-	   SCALE (size), LABEL (size));
-
-  size = dfa_stats.num_var_anns * sizeof (struct var_ann_d);
-  total += size;
-  fprintf (file, fmt_str_1, "Variables annotated", dfa_stats.num_var_anns,
-	   SCALE (size), LABEL (size));
-
   size = dfa_stats.num_uses * sizeof (tree *);
   total += size;
   fprintf (file, fmt_str_1, "USE operands", dfa_stats.num_uses,
@@ -351,7 +218,7 @@
   fprintf (file, fmt_str_1, "VDEF operands", dfa_stats.num_vdefs,
 	   SCALE (size), LABEL (size));
 
-  size = dfa_stats.num_phis * sizeof (struct gimple_statement_phi);
+  size = dfa_stats.num_phis * sizeof (struct gphi);
   total += size;
   fprintf (file, fmt_str_1, "PHI nodes", dfa_stats.num_phis,
 	   SCALE (size), LABEL (size));
@@ -392,35 +259,28 @@
 collect_dfa_stats (struct dfa_stats_d *dfa_stats_p ATTRIBUTE_UNUSED)
 {
   basic_block bb;
-  referenced_var_iterator vi;
-  tree var;
 
   gcc_assert (dfa_stats_p);
 
   memset ((void *)dfa_stats_p, 0, sizeof (struct dfa_stats_d));
 
-  /* Count all the variable annotations.  */
-  FOR_EACH_REFERENCED_VAR (cfun, var, vi)
-    if (var_ann (var))
-      dfa_stats_p->num_var_anns++;
-
   /* Walk all the statements in the function counting references.  */
-  FOR_EACH_BB (bb)
+  FOR_EACH_BB_FN (bb, cfun)
     {
-      gimple_stmt_iterator si;
-
-      for (si = gsi_start_phis (bb); !gsi_end_p (si); gsi_next (&si))
+      for (gphi_iterator si = gsi_start_phis (bb); !gsi_end_p (si);
+	   gsi_next (&si))
 	{
-	  gimple phi = gsi_stmt (si);
+	  gphi *phi = si.phi ();
 	  dfa_stats_p->num_phis++;
 	  dfa_stats_p->num_phi_args += gimple_phi_num_args (phi);
 	  if (gimple_phi_num_args (phi) > dfa_stats_p->max_num_phi_args)
 	    dfa_stats_p->max_num_phi_args = gimple_phi_num_args (phi);
 	}
 
-      for (si = gsi_start_bb (bb); !gsi_end_p (si); gsi_next (&si))
+      for (gimple_stmt_iterator si = gsi_start_bb (bb); !gsi_end_p (si);
+	   gsi_next (&si))
 	{
-	  gimple stmt = gsi_stmt (si);
+	  gimple *stmt = gsi_stmt (si);
 	  dfa_stats_p->num_defs += NUM_SSA_OPERANDS (stmt, SSA_OP_DEF);
 	  dfa_stats_p->num_uses += NUM_SSA_OPERANDS (stmt, SSA_OP_USE);
 	  dfa_stats_p->num_vdefs += gimple_vdef (stmt) ? 1 : 0;
@@ -433,263 +293,79 @@
 /*---------------------------------------------------------------------------
 			     Miscellaneous helpers
 ---------------------------------------------------------------------------*/
-/* Callback for walk_tree.  Used to collect variables referenced in
-   the function.  */
-
-static tree
-find_vars_r (tree *tp, int *walk_subtrees, void *data ATTRIBUTE_UNUSED)
-{
-  /* If we are reading the lto info back in, we need to rescan the
-     referenced vars.  */
-  if (TREE_CODE (*tp) == SSA_NAME)
-    add_referenced_var (SSA_NAME_VAR (*tp));
-
-  /* If T is a regular variable that the optimizers are interested
-     in, add it to the list of variables.  */
-  else if (SSA_VAR_P (*tp))
-    add_referenced_var (*tp);
-
-  /* Type, _DECL and constant nodes have no interesting children.
-     Ignore them.  */
-  else if (IS_TYPE_OR_DECL_P (*tp) || CONSTANT_CLASS_P (*tp))
-    *walk_subtrees = 0;
-
-  return NULL_TREE;
-}
-
-/* Find referenced variables in STMT.  In contrast with
-   find_new_referenced_vars, this function will not mark newly found
-   variables for renaming.  */
-
-void
-find_referenced_vars_in (gimple stmt)
-{
-  size_t i;
-
-  if (gimple_code (stmt) != GIMPLE_PHI)
-    {
-      for (i = 0; i < gimple_num_ops (stmt); i++)
-	walk_tree (gimple_op_ptr (stmt, i), find_vars_r, NULL, NULL);
-    }
-  else
-    {
-      walk_tree (gimple_phi_result_ptr (stmt), find_vars_r, NULL, NULL);
-
-      for (i = 0; i < gimple_phi_num_args (stmt); i++)
-	{
-	  tree arg = gimple_phi_arg_def (stmt, i);
-	  walk_tree (&arg, find_vars_r, NULL, NULL);
-	}
-    }
-}
-
-
-/* Lookup UID in the referenced_vars hashtable and return the associated
-   variable.  */
-
-tree
-referenced_var_lookup (struct function *fn, unsigned int uid)
-{
-  tree h;
-  struct tree_decl_minimal in;
-  in.uid = uid;
-  h = (tree) htab_find_with_hash (gimple_referenced_vars (fn), &in, uid);
-  return h;
-}
-
-/* Check if TO is in the referenced_vars hash table and insert it if not.
-   Return true if it required insertion.  */
-
-bool
-referenced_var_check_and_insert (tree to)
-{
-  tree h, *loc;
-  struct tree_decl_minimal in;
-  unsigned int uid = DECL_UID (to);
-
-  in.uid = uid;
-  h = (tree) 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);
-      return false;
-    }
-
-  loc = (tree *) htab_find_slot_with_hash (gimple_referenced_vars (cfun),
-					   &in, uid, INSERT);
-  *loc = to;
-  return true;
-}
 
 /* Lookup VAR UID in the default_defs hashtable and return the associated
    variable.  */
 
 tree
-gimple_default_def (struct function *fn, tree var)
+ssa_default_def (struct function *fn, tree var)
 {
   struct tree_decl_minimal ind;
   struct tree_ssa_name in;
-  gcc_assert (SSA_VAR_P (var));
+  gcc_assert (VAR_P (var)
+	      || TREE_CODE (var) == PARM_DECL
+	      || TREE_CODE (var) == RESULT_DECL);
+
+  /* Always NULL_TREE for rtl function dumps.  */
+  if (!fn->gimple_df)
+    return NULL_TREE;
+
   in.var = (tree)&ind;
   ind.uid = DECL_UID (var);
-  return (tree) htab_find_with_hash (DEFAULT_DEFS (fn), &in, DECL_UID (var));
+  return DEFAULT_DEFS (fn)->find_with_hash ((tree)&in, DECL_UID (var));
 }
 
-/* Insert the pair VAR's UID, DEF into the default_defs hashtable.  */
+/* Insert the pair VAR's UID, DEF into the default_defs hashtable
+   of function FN.  */
 
 void
-set_default_def (tree var, tree def)
+set_ssa_default_def (struct function *fn, tree var, tree def)
 {
   struct tree_decl_minimal ind;
   struct tree_ssa_name in;
-  void **loc;
 
-  gcc_assert (SSA_VAR_P (var));
+  gcc_assert (VAR_P (var)
+	      || TREE_CODE (var) == PARM_DECL
+	      || TREE_CODE (var) == RESULT_DECL);
   in.var = (tree)&ind;
   ind.uid = DECL_UID (var);
   if (!def)
     {
-      loc = htab_find_slot_with_hash (DEFAULT_DEFS (cfun), &in,
-            DECL_UID (var), INSERT);
-      gcc_assert (*loc);
-      htab_remove_elt (DEFAULT_DEFS (cfun), *loc);
+      tree *loc = DEFAULT_DEFS (fn)->find_slot_with_hash ((tree)&in,
+							  DECL_UID (var),
+							  NO_INSERT);
+      if (loc)
+	{
+	  SSA_NAME_IS_DEFAULT_DEF (*(tree *)loc) = false;
+	  DEFAULT_DEFS (fn)->clear_slot (loc);
+	}
       return;
     }
   gcc_assert (TREE_CODE (def) == SSA_NAME && SSA_NAME_VAR (def) == var);
-  loc = htab_find_slot_with_hash (DEFAULT_DEFS (cfun), &in,
-                                  DECL_UID (var), INSERT);
+  tree *loc = DEFAULT_DEFS (fn)->find_slot_with_hash ((tree)&in,
+						      DECL_UID (var), INSERT);
 
   /* Default definition might be changed by tail call optimization.  */
   if (*loc)
-    SSA_NAME_IS_DEFAULT_DEF (*(tree *) loc) = false;
-  *(tree *) loc = def;
+    SSA_NAME_IS_DEFAULT_DEF (*loc) = false;
 
    /* Mark DEF as the default definition for VAR.  */
-   SSA_NAME_IS_DEFAULT_DEF (def) = true;
+  *loc = def;
+  SSA_NAME_IS_DEFAULT_DEF (def) = true;
 }
 
-/* Add VAR to the list of referenced variables if it isn't already there.  */
-
-bool
-add_referenced_var (tree var)
-{
-  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))
-    {
-      /* Scan DECL_INITIAL for pointer variables as they may contain
-	 address arithmetic referencing the address of other
-	 variables.  As we are only interested in directly referenced
-	 globals or referenced locals restrict this to initializers
-	 than can refer to local variables.  */
-      if (DECL_INITIAL (var)
-          && DECL_CONTEXT (var) == current_function_decl)
-      	walk_tree (&DECL_INITIAL (var), find_vars_r, NULL, 0);
-
-      return true;
-    }
-
-  return false;
-}
-
-/* Remove VAR from the list.  */
-
-void
-remove_referenced_var (tree var)
-{
-  var_ann_t v_ann;
-  struct tree_decl_minimal in;
-  void **loc;
-  unsigned int uid = DECL_UID (var);
-
-  /* Preserve var_anns of globals.  */
-  if (!is_global_var (var)
-      && (v_ann = var_ann (var)))
-    {
-      ggc_free (v_ann);
-      *DECL_VAR_ANN_PTR (var) = NULL;
-    }
-  gcc_assert (DECL_P (var));
-  in.uid = uid;
-  loc = htab_find_slot_with_hash (gimple_referenced_vars (cfun), &in, uid,
-				  NO_INSERT);
-  htab_clear_slot (gimple_referenced_vars (cfun), loc);
-}
-
-
-/* Return the virtual variable associated to the non-scalar variable VAR.  */
+/* Retrieve or create a default definition for VAR.  */
 
 tree
-get_virtual_var (tree var)
-{
-  STRIP_NOPS (var);
-
-  if (TREE_CODE (var) == SSA_NAME)
-    var = SSA_NAME_VAR (var);
-
-  while (TREE_CODE (var) == REALPART_EXPR || TREE_CODE (var) == IMAGPART_EXPR
-	 || handled_component_p (var))
-    var = TREE_OPERAND (var, 0);
-
-  /* Treating GIMPLE registers as virtual variables makes no sense.
-     Also complain if we couldn't extract a _DECL out of the original
-     expression.  */
-  gcc_assert (SSA_VAR_P (var));
-  gcc_assert (!is_gimple_reg (var));
-
-  return var;
-}
-
-/* Mark all the naked symbols in STMT for SSA renaming.  */
-
-void
-mark_symbols_for_renaming (gimple stmt)
+get_or_create_ssa_default_def (struct function *fn, tree var)
 {
-  tree op;
-  ssa_op_iter iter;
-
-  update_stmt (stmt);
-
-  /* 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.  */
-
-static tree
-find_new_referenced_vars_1 (tree *tp, int *walk_subtrees,
-			    void *data ATTRIBUTE_UNUSED)
-{
-  tree t = *tp;
-
-  if (TREE_CODE (t) == VAR_DECL && !var_ann (t))
+  tree ddef = ssa_default_def (fn, var);
+  if (ddef == NULL_TREE)
     {
-      add_referenced_var (t);
-      mark_sym_for_renaming (t);
+      ddef = make_ssa_name_fn (fn, var, gimple_build_nop ());
+      set_ssa_default_def (fn, var, ddef);
     }
-
-  if (IS_TYPE_OR_DECL_P (t))
-    *walk_subtrees = 0;
-
-  return NULL;
-}
-
-
-/* Find any new referenced variables in STMT.  */
-
-void
-find_new_referenced_vars (gimple stmt)
-{
-  walk_gimple_op (stmt, find_new_referenced_vars_1, NULL);
+  return ddef;
 }
 
 
@@ -697,39 +373,40 @@
    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.  */
+   and *PMAX_SIZE are equal, the access is non-variable.  If *PREVERSE is
+   true, the storage order of the reference is reversed.  */
 
 tree
 get_ref_base_and_extent (tree exp, HOST_WIDE_INT *poffset,
 			 HOST_WIDE_INT *psize,
-			 HOST_WIDE_INT *pmax_size)
+			 HOST_WIDE_INT *pmax_size,
+			 bool *preverse)
 {
-  HOST_WIDE_INT bitsize = -1;
-  HOST_WIDE_INT maxsize = -1;
+  offset_int bitsize = -1;
+  offset_int maxsize;
   tree size_tree = NULL_TREE;
-  HOST_WIDE_INT bit_offset = 0;
+  offset_int bit_offset = 0;
   bool seen_variable_array_ref = false;
 
-  /* First get the final access size from just the outermost expression.  */
+  /* First get the final access size and the storage order 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 if (!VOID_TYPE_P (TREE_TYPE (exp)))
     {
-      enum machine_mode mode = TYPE_MODE (TREE_TYPE (exp));
+      machine_mode mode = TYPE_MODE (TREE_TYPE (exp));
       if (mode == BLKmode)
 	size_tree = TYPE_SIZE (TREE_TYPE (exp));
       else
-	bitsize = GET_MODE_BITSIZE (mode);
+	bitsize = int (GET_MODE_BITSIZE (mode));
     }
-  if (size_tree != NULL_TREE)
-    {
-      if (! host_integerp (size_tree, 1))
-	bitsize = -1;
-      else
-	bitsize = TREE_INT_CST_LOW (size_tree);
-    }
+  if (size_tree != NULL_TREE
+      && TREE_CODE (size_tree) == INTEGER_CST)
+    bitsize = wi::to_offset (size_tree);
+
+  *preverse = reverse_storage_order_for_component_p (exp);
 
   /* Initially, maxsize is the same as the accessed element size.
      In the following it will only grow (or become -1).  */
@@ -742,7 +419,7 @@
       switch (TREE_CODE (exp))
 	{
 	case BIT_FIELD_REF:
-	  bit_offset += TREE_INT_CST_LOW (TREE_OPERAND (exp, 2));
+	  bit_offset += wi::to_offset (TREE_OPERAND (exp, 2));
 	  break;
 
 	case COMPONENT_REF:
@@ -750,22 +427,18 @@
 	    tree field = TREE_OPERAND (exp, 1);
 	    tree this_offset = component_ref_field_offset (exp);
 
-	    if (this_offset
-		&& TREE_CODE (this_offset) == INTEGER_CST
-		&& host_integerp (this_offset, 0))
+	    if (this_offset && TREE_CODE (this_offset) == INTEGER_CST)
 	      {
-		HOST_WIDE_INT hthis_offset = TREE_INT_CST_LOW (this_offset);
-		hthis_offset *= BITS_PER_UNIT;
-		hthis_offset
-		  += TREE_INT_CST_LOW (DECL_FIELD_BIT_OFFSET (field));
-		bit_offset += hthis_offset;
+		offset_int woffset = (wi::to_offset (this_offset)
+				      << LOG2_BITS_PER_UNIT);
+		woffset += wi::to_offset (DECL_FIELD_BIT_OFFSET (field));
+		bit_offset += woffset;
 
 		/* If we had seen a variable array ref already and we just
 		   referenced the last field of a struct or a union member
 		   then we have to adjust maxsize by the padding at the end
 		   of our field.  */
-		if (seen_variable_array_ref
-		    && maxsize != -1)
+		if (seen_variable_array_ref && maxsize != -1)
 		  {
 		    tree stype = TREE_TYPE (TREE_OPERAND (exp, 0));
 		    tree next = DECL_CHAIN (field);
@@ -776,13 +449,19 @@
 		      {
 			tree fsize = DECL_SIZE_UNIT (field);
 			tree ssize = TYPE_SIZE_UNIT (stype);
-			if (host_integerp (fsize, 0)
-			    && host_integerp (ssize, 0))
-			  maxsize += ((TREE_INT_CST_LOW (ssize)
-				       - TREE_INT_CST_LOW (fsize))
-				      * BITS_PER_UNIT - hthis_offset);
+			if (fsize == NULL
+			    || TREE_CODE (fsize) != INTEGER_CST
+			    || ssize == NULL
+			    || TREE_CODE (ssize) != INTEGER_CST)
+			  maxsize = -1;
 			else
-			  maxsize = -1;
+			  {
+			    offset_int tem = (wi::to_offset (ssize)
+					      - wi::to_offset (fsize));
+			    tem <<= LOG2_BITS_PER_UNIT;
+			    tem -= woffset;
+			    maxsize += tem;
+			  }
 		      }
 		  }
 	      }
@@ -792,8 +471,10 @@
 		/* We need to adjust maxsize to the whole structure bitsize.
 		   But we can subtract any constant offset seen so far,
 		   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;
+		if (maxsize != -1
+		    && csize
+		    && TREE_CODE (csize) == INTEGER_CST)
+		  maxsize = wi::to_offset (csize) - bit_offset;
 		else
 		  maxsize = -1;
 	      }
@@ -808,18 +489,17 @@
 
 	    /* If the resulting bit-offset is constant, track it.  */
 	    if (TREE_CODE (index) == INTEGER_CST
-		&& host_integerp (index, 0)
 		&& (low_bound = array_ref_low_bound (exp),
-		    host_integerp (low_bound, 0))
+ 		    TREE_CODE (low_bound) == INTEGER_CST)
 		&& (unit_size = array_ref_element_size (exp),
-		    host_integerp (unit_size, 1)))
+		    TREE_CODE (unit_size) == INTEGER_CST))
 	      {
-		HOST_WIDE_INT hindex = TREE_INT_CST_LOW (index);
-
-		hindex -= TREE_INT_CST_LOW (low_bound);
-		hindex *= TREE_INT_CST_LOW (unit_size);
-		hindex *= BITS_PER_UNIT;
-		bit_offset += hindex;
+		offset_int woffset
+		  = wi::sext (wi::to_offset (index) - wi::to_offset (low_bound),
+			      TYPE_PRECISION (TREE_TYPE (index)));
+		woffset *= wi::to_offset (unit_size);
+		woffset <<= LOG2_BITS_PER_UNIT;
+		bit_offset += woffset;
 
 		/* An array ref with a constant index up in the structure
 		   hierarchy will constrain the size of any variable array ref
@@ -832,8 +512,10 @@
 		/* We need to adjust maxsize to the whole array bitsize.
 		   But we can subtract any constant offset seen so far,
 		   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;
+		if (maxsize != -1
+		    && asize
+		    && TREE_CODE (asize) == INTEGER_CST)
+		  maxsize = wi::to_offset (asize) - bit_offset;
 		else
 		  maxsize = -1;
 
@@ -854,7 +536,37 @@
 	case VIEW_CONVERT_EXPR:
 	  break;
 
+	case TARGET_MEM_REF:
+	  /* Via the variable index or index2 we can reach the
+	     whole object.  Still hand back the decl here.  */
+	  if (TREE_CODE (TMR_BASE (exp)) == ADDR_EXPR
+	      && (TMR_INDEX (exp) || TMR_INDEX2 (exp)))
+	    {
+	      exp = TREE_OPERAND (TMR_BASE (exp), 0);
+	      bit_offset = 0;
+	      maxsize = -1;
+	      goto done;
+	    }
+	  /* Fallthru.  */
 	case MEM_REF:
+	  /* 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]
+	     struct { int len; union { int a[1]; struct X x; } u; } x; x.u.a[d]
+	     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.  This needs to include possible trailing
+	     padding that is there for alignment purposes.  */
+	  if (seen_variable_array_ref
+	      && maxsize != -1
+	      && (TYPE_SIZE (TREE_TYPE (exp)) == NULL_TREE
+		  || TREE_CODE (TYPE_SIZE (TREE_TYPE (exp))) != INTEGER_CST
+		  || (bit_offset + maxsize
+		      == wi::to_offset (TYPE_SIZE (TREE_TYPE (exp))))))
+	    maxsize = -1;
+
 	  /* Hand back the decl for MEM[&decl, off].  */
 	  if (TREE_CODE (TREE_OPERAND (exp, 0)) == ADDR_EXPR)
 	    {
@@ -862,95 +574,102 @@
 		exp = TREE_OPERAND (TREE_OPERAND (exp, 0), 0);
 	      else
 		{
-		  double_int off = mem_ref_offset (exp);
-		  off = double_int_lshift (off,
-					   BITS_PER_UNIT == 8
-					   ? 3 : exact_log2 (BITS_PER_UNIT),
-					   HOST_BITS_PER_DOUBLE_INT, true);
-		  off = double_int_add (off, shwi_to_double_int (bit_offset));
-		  if (double_int_fits_in_shwi_p (off))
+		  offset_int off = mem_ref_offset (exp);
+		  off <<= LOG2_BITS_PER_UNIT;
+		  off += bit_offset;
+		  if (wi::fits_shwi_p (off))
 		    {
-		      bit_offset = double_int_to_shwi (off);
+		      bit_offset = off;
 		      exp = TREE_OPERAND (TREE_OPERAND (exp, 0), 0);
 		    }
 		}
 	    }
 	  goto done;
 
-	case TARGET_MEM_REF:
-	  /* Hand back the decl for MEM[&decl, off].  */
-	  if (TREE_CODE (TMR_BASE (exp)) == ADDR_EXPR)
-	    {
-	      /* Via the variable index or index2 we can reach the
-		 whole object.  */
-	      if (TMR_INDEX (exp) || TMR_INDEX2 (exp))
-		{
-		  exp = TREE_OPERAND (TMR_BASE (exp), 0);
-		  bit_offset = 0;
-		  maxsize = -1;
-		  goto done;
-		}
-	      if (integer_zerop (TMR_OFFSET (exp)))
-		exp = TREE_OPERAND (TMR_BASE (exp), 0);
-	      else
-		{
-		  double_int off = mem_ref_offset (exp);
-		  off = double_int_lshift (off,
-					   BITS_PER_UNIT == 8
-					   ? 3 : exact_log2 (BITS_PER_UNIT),
-					   HOST_BITS_PER_DOUBLE_INT, true);
-		  off = double_int_add (off, shwi_to_double_int (bit_offset));
-		  if (double_int_fits_in_shwi_p (off))
-		    {
-		      bit_offset = double_int_to_shwi (off);
-		      exp = TREE_OPERAND (TMR_BASE (exp), 0);
-		    }
-		}
-	    }
-	  goto done;
-
 	default:
 	  goto done;
 	}
 
       exp = TREE_OPERAND (exp, 0);
     }
+
  done:
+  if (!wi::fits_shwi_p (bitsize) || wi::neg_p (bitsize))
+    {
+      *poffset = 0;
+      *psize = -1;
+      *pmax_size = -1;
+
+      return exp;
+    }
 
-  /* 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]
-       struct { int len; union { int a[1]; struct X x; } u; } x; x.u.a[d]
-     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.  This needs to include possible trailing padding
-     that is there for alignment purposes.
+  *psize = bitsize.to_shwi ();
 
-     That is of course only true if the base object is not a decl.  */
+  if (!wi::fits_shwi_p (bit_offset))
+    {
+      *poffset = 0;
+      *pmax_size = -1;
+
+      return exp;
+    }
+
+  /* In case of a decl or constant base object we can do better.  */
 
   if (DECL_P (exp))
     {
+      if (flag_unconstrained_commons && VAR_P (exp) && DECL_COMMON (exp))
+	{
+	  tree sz_tree = TYPE_SIZE (TREE_TYPE (exp));
+	  /* If size is unknown, or we have read to the end, assume there
+	     may be more to the structure than we are told.  */
+	  if (TREE_CODE (TREE_TYPE (exp)) == ARRAY_TYPE
+	      || (seen_variable_array_ref
+		  && (sz_tree == NULL_TREE
+		      || TREE_CODE (sz_tree) != INTEGER_CST
+		      || (bit_offset + maxsize == wi::to_offset (sz_tree)))))
+	    maxsize = -1;
+	}
       /* If maxsize is unknown adjust it according to the size of the
          base decl.  */
-      if (maxsize == -1
-	  && host_integerp (DECL_SIZE (exp), 1))
-	maxsize = TREE_INT_CST_LOW (DECL_SIZE (exp)) - bit_offset;
+      else if (maxsize == -1
+	  && DECL_SIZE (exp)
+	  && TREE_CODE (DECL_SIZE (exp)) == INTEGER_CST)
+	maxsize = wi::to_offset (DECL_SIZE (exp)) - bit_offset;
     }
-  else 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;
+  else if (CONSTANT_CLASS_P (exp))
+    {
+      /* If maxsize is unknown adjust it according to the size of the
+         base type constant.  */
+      if (maxsize == -1
+	  && TYPE_SIZE (TREE_TYPE (exp))
+	  && TREE_CODE (TYPE_SIZE (TREE_TYPE (exp))) == INTEGER_CST)
+	maxsize = (wi::to_offset (TYPE_SIZE (TREE_TYPE (exp)))
+		   - bit_offset);
+    }
 
   /* ???  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;
+  *poffset = bit_offset.to_shwi ();
+  if (!wi::fits_shwi_p (maxsize) || wi::neg_p (maxsize))
+    *pmax_size = -1;
+  else
+    {
+      *pmax_size = maxsize.to_shwi ();
+      if (*poffset > HOST_WIDE_INT_MAX - *pmax_size)
+	*pmax_size = -1;
+    }
+
+  /* Punt if *POFFSET + *PSIZE overflows in HOST_WIDE_INT, the callers don't
+     check for such overflows individually and assume it works.  */
+  if (*psize != -1 && *poffset > HOST_WIDE_INT_MAX - *psize)
+    {
+      *poffset = 0;
+      *psize = -1;
+      *pmax_size = -1;
+
+      return exp;
+    }
 
   return exp;
 }
@@ -958,10 +677,13 @@
 /* Returns the base object and a constant BITS_PER_UNIT offset in *POFFSET that
    denotes the starting address of the memory access EXP.
    Returns NULL_TREE if the offset is not constant or any component
-   is not BITS_PER_UNIT-aligned.  */
+   is not BITS_PER_UNIT-aligned.
+   VALUEIZE if non-NULL is used to valueize SSA names.  It should return
+   its argument or a constant if the argument is known to be constant.  */
 
 tree
-get_addr_base_and_unit_offset (tree exp, HOST_WIDE_INT *poffset)
+get_addr_base_and_unit_offset_1 (tree exp, HOST_WIDE_INT *poffset,
+				 tree (*valueize) (tree))
 {
   HOST_WIDE_INT byte_offset = 0;
 
@@ -972,7 +694,13 @@
       switch (TREE_CODE (exp))
 	{
 	case BIT_FIELD_REF:
-	  return NULL_TREE;
+	  {
+	    HOST_WIDE_INT this_off = TREE_INT_CST_LOW (TREE_OPERAND (exp, 2));
+	    if (this_off % BITS_PER_UNIT)
+	      return NULL_TREE;
+	    byte_offset += this_off / BITS_PER_UNIT;
+	  }
+	  break;
 
 	case COMPONENT_REF:
 	  {
@@ -999,6 +727,10 @@
 	    tree index = TREE_OPERAND (exp, 1);
 	    tree low_bound, unit_size;
 
+	    if (valueize
+		&& TREE_CODE (index) == SSA_NAME)
+	      index = (*valueize) (index);
+
 	    /* If the resulting bit-offset is constant, track it.  */
 	    if (TREE_CODE (index) == INTEGER_CST
 		&& (low_bound = array_ref_low_bound (exp),
@@ -1006,11 +738,11 @@
 		&& (unit_size = array_ref_element_size (exp),
 		    TREE_CODE (unit_size) == INTEGER_CST))
 	      {
-		HOST_WIDE_INT hindex = TREE_INT_CST_LOW (index);
-
-		hindex -= TREE_INT_CST_LOW (low_bound);
-		hindex *= TREE_INT_CST_LOW (unit_size);
-		byte_offset += hindex;
+		offset_int woffset
+		  = wi::sext (wi::to_offset (index) - wi::to_offset (low_bound),
+			      TYPE_PRECISION (TREE_TYPE (index)));
+		woffset *= wi::to_offset (unit_size);
+		byte_offset += woffset.to_shwi ();
 	      }
 	    else
 	      return NULL_TREE;
@@ -1028,34 +760,46 @@
 	  break;
 
 	case MEM_REF:
-	  /* Hand back the decl for MEM[&decl, off].  */
-	  if (TREE_CODE (TREE_OPERAND (exp, 0)) == ADDR_EXPR)
-	    {
-	      if (!integer_zerop (TREE_OPERAND (exp, 1)))
-		{
-		  double_int off = mem_ref_offset (exp);
-		  gcc_assert (off.high == -1 || off.high == 0);
-		  byte_offset += double_int_to_shwi (off);
-		}
-	      exp = TREE_OPERAND (TREE_OPERAND (exp, 0), 0);
-	    }
-	  goto done;
+	  {
+	    tree base = TREE_OPERAND (exp, 0);
+	    if (valueize
+		&& TREE_CODE (base) == SSA_NAME)
+	      base = (*valueize) (base);
+
+	    /* Hand back the decl for MEM[&decl, off].  */
+	    if (TREE_CODE (base) == ADDR_EXPR)
+	      {
+		if (!integer_zerop (TREE_OPERAND (exp, 1)))
+		  {
+		    offset_int off = mem_ref_offset (exp);
+		    byte_offset += off.to_short_addr ();
+		  }
+		exp = TREE_OPERAND (base, 0);
+	      }
+	    goto done;
+	  }
 
 	case TARGET_MEM_REF:
-	  /* Hand back the decl for MEM[&decl, off].  */
-	  if (TREE_CODE (TMR_BASE (exp)) == ADDR_EXPR)
-	    {
-	      if (TMR_INDEX (exp) || TMR_INDEX2 (exp))
-		return NULL_TREE;
-	      if (!integer_zerop (TMR_OFFSET (exp)))
-		{
-		  double_int off = mem_ref_offset (exp);
-		  gcc_assert (off.high == -1 || off.high == 0);
-		  byte_offset += double_int_to_shwi (off);
-		}
-	      exp = TREE_OPERAND (TMR_BASE (exp), 0);
-	    }
-	  goto done;
+	  {
+	    tree base = TREE_OPERAND (exp, 0);
+	    if (valueize
+		&& TREE_CODE (base) == SSA_NAME)
+	      base = (*valueize) (base);
+
+	    /* Hand back the decl for MEM[&decl, off].  */
+	    if (TREE_CODE (base) == ADDR_EXPR)
+	      {
+		if (TMR_INDEX (exp) || TMR_INDEX2 (exp))
+		  return NULL_TREE;
+		if (!integer_zerop (TMR_OFFSET (exp)))
+		  {
+		    offset_int off = mem_ref_offset (exp);
+		    byte_offset += off.to_short_addr ();
+		  }
+		exp = TREE_OPERAND (base, 0);
+	      }
+	    goto done;
+	  }
 
 	default:
 	  goto done;
@@ -1069,11 +813,22 @@
   return exp;
 }
 
+/* Returns the base object and a constant BITS_PER_UNIT offset in *POFFSET that
+   denotes the starting address of the memory access EXP.
+   Returns NULL_TREE if the offset is not constant or any component
+   is not BITS_PER_UNIT-aligned.  */
+
+tree
+get_addr_base_and_unit_offset (tree exp, HOST_WIDE_INT *poffset)
+{
+  return get_addr_base_and_unit_offset_1 (exp, poffset, NULL);
+}
+
 /* Returns true if STMT references an SSA_NAME that has
    SSA_NAME_OCCURS_IN_ABNORMAL_PHI set, otherwise false.  */
 
 bool
-stmt_references_abnormal_ssa_name (gimple stmt)
+stmt_references_abnormal_ssa_name (gimple *stmt)
 {
   ssa_op_iter oi;
   use_operand_p use_p;
@@ -1087,3 +842,110 @@
   return false;
 }
 
+/* If STMT takes any abnormal PHI values as input, replace them with
+   local copies.  */
+
+void
+replace_abnormal_ssa_names (gimple *stmt)
+{
+  ssa_op_iter oi;
+  use_operand_p use_p;
+
+  FOR_EACH_SSA_USE_OPERAND (use_p, stmt, oi, SSA_OP_USE)
+    {
+      tree op = USE_FROM_PTR (use_p);
+      if (TREE_CODE (op) == SSA_NAME && SSA_NAME_OCCURS_IN_ABNORMAL_PHI (op))
+	{
+	  gimple_stmt_iterator gsi = gsi_for_stmt (stmt);
+	  tree new_name = make_ssa_name (TREE_TYPE (op));
+	  gassign *assign = gimple_build_assign (new_name, op);
+	  gsi_insert_before (&gsi, assign, GSI_SAME_STMT);
+	  SET_USE (use_p, new_name);
+	}
+    }
+}
+
+/* Pair of tree and a sorting index, for dump_enumerated_decls.  */
+struct GTY(()) numbered_tree
+{
+  tree t;
+  int num;
+};
+
+
+/* Compare two declarations references by their DECL_UID / sequence number.
+   Called via qsort.  */
+
+static int
+compare_decls_by_uid (const void *pa, const void *pb)
+{
+  const numbered_tree *nt_a = ((const numbered_tree *)pa);
+  const numbered_tree *nt_b = ((const numbered_tree *)pb);
+
+  if (DECL_UID (nt_a->t) != DECL_UID (nt_b->t))
+    return  DECL_UID (nt_a->t) - DECL_UID (nt_b->t);
+  return nt_a->num - nt_b->num;
+}
+
+/* Called via walk_gimple_stmt / walk_gimple_op by dump_enumerated_decls.  */
+static tree
+dump_enumerated_decls_push (tree *tp, int *walk_subtrees, void *data)
+{
+  struct walk_stmt_info *wi = (struct walk_stmt_info *) data;
+  vec<numbered_tree> *list = (vec<numbered_tree> *) wi->info;
+  numbered_tree nt;
+
+  if (!DECL_P (*tp))
+    return NULL_TREE;
+  nt.t = *tp;
+  nt.num = list->length ();
+  list->safe_push (nt);
+  *walk_subtrees = 0;
+  return NULL_TREE;
+}
+
+/* Find all the declarations used by the current function, sort them by uid,
+   and emit the sorted list.  Each declaration is tagged with a sequence
+   number indicating when it was found during statement / tree walking,
+   so that TDF_NOUID comparisons of anonymous declarations are still
+   meaningful.  Where a declaration was encountered more than once, we
+   emit only the sequence number of the first encounter.
+   FILE is the dump file where to output the list and FLAGS is as in
+   print_generic_expr.  */
+void
+dump_enumerated_decls (FILE *file, dump_flags_t flags)
+{
+  basic_block bb;
+  struct walk_stmt_info wi;
+  auto_vec<numbered_tree, 40> decl_list;
+
+  memset (&wi, '\0', sizeof (wi));
+  wi.info = (void *) &decl_list;
+  FOR_EACH_BB_FN (bb, cfun)
+    {
+      gimple_stmt_iterator gsi;
+
+      for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
+	if (!is_gimple_debug (gsi_stmt (gsi)))
+	  walk_gimple_stmt (&gsi, NULL, dump_enumerated_decls_push, &wi);
+    }
+  decl_list.qsort (compare_decls_by_uid);
+  if (decl_list.length ())
+    {
+      unsigned ix;
+      numbered_tree *ntp;
+      tree last = NULL_TREE;
+
+      fprintf (file, "Declarations used by %s, sorted by DECL_UID:\n",
+	       current_function_name ());
+      FOR_EACH_VEC_ELT (decl_list, ix, ntp)
+	{
+	  if (ntp->t == last)
+	    continue;
+	  fprintf (file, "%d: ", ntp->num);
+	  print_generic_decl (file, ntp->t, flags);
+	  fprintf (file, "\n");
+	  last = ntp->t;
+	}
+    }
+}