OSDN Git Service

2010-04-07 Richard Guenther <rguenther@suse.de>
authorrguenth <rguenth@138bc75d-0d04-0410-961f-82ee72b054a4>
Wed, 7 Apr 2010 15:31:37 +0000 (15:31 +0000)
committerMasaki Muranaka <monaka@monami-software.com>
Sun, 23 May 2010 00:49:44 +0000 (09:49 +0900)
* ipa-reference.c (mark_load): Use get_base_address.
(mark_store): Likewise.

* tree-ssa-ccp.c (gimplify_and_update_call_from_tree): Avoid
inserting GIMPLE_NOPs into the IL.
* tree-ssa-structalias.c (get_constraint_for_component_ref):
Explicitly strip handled components and indirect references.

* fold-const.c (fold_unary_loc): Do not strip qualifiers when
folding address expressions.
* gimple.c (gimple_ior_addresses_taken_1): Use get_base_address.
* tree-ssa-alias.c (decl_refs_may_alias_p): Do not use
operand_equal_p to compare decls.
(ptr_deref_may_alias_decl_p): Likewise.
* tree-ssa-operands.c (get_asm_expr_operands): Simplify
* tree-ssa-forwprop.c (forward_propagate_into_gimple_cond):
Handle reversed comparison ops.
* tree-sra.c (asm_visit_addr): Use get_base_address.
* ipa-prop.c (visit_store_addr_for_mod_analysis): Use
get_base_address.
* ipa-reference.c (mark_address): Use get_base_address.

git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@158069 138bc75d-0d04-0410-961f-82ee72b054a4

gcc/ChangeLog
gcc/ipa-reference.c
gcc/tree-ssa-ccp.c

index 20aa611..693d69d 100644 (file)
@@ -1,5 +1,29 @@
 2010-04-07  Richard Guenther  <rguenther@suse.de>
 
+       * ipa-reference.c (mark_load): Use get_base_address.
+       (mark_store): Likewise.
+
+       * tree-ssa-ccp.c (gimplify_and_update_call_from_tree): Avoid
+       inserting GIMPLE_NOPs into the IL.
+       * tree-ssa-structalias.c (get_constraint_for_component_ref):
+       Explicitly strip handled components and indirect references.
+  
+       * fold-const.c (fold_unary_loc): Do not strip qualifiers when
+       folding address expressions.
+       * gimple.c (gimple_ior_addresses_taken_1): Use get_base_address.
+       * tree-ssa-alias.c (decl_refs_may_alias_p): Do not use
+       operand_equal_p to compare decls.
+       (ptr_deref_may_alias_decl_p): Likewise.
+       * tree-ssa-operands.c (get_asm_expr_operands): Simplify
+       * tree-ssa-forwprop.c (forward_propagate_into_gimple_cond):
+       Handle reversed comparison ops.
+       * tree-sra.c (asm_visit_addr): Use get_base_address.
+       * ipa-prop.c (visit_store_addr_for_mod_analysis): Use
+       get_base_address.
+       * ipa-reference.c (mark_address): Use get_base_address.
+
+2010-04-07  Richard Guenther  <rguenther@suse.de>
+
        * tree-ssa-forwprop.c (forward_propagate_addr_expr):
        Propagate constants everywhere.
 
index a66e627..9eac3b1 100644 (file)
@@ -22,7 +22,13 @@ along with GCC; see the file COPYING3.  If not see
 /* This file gathers information about how variables whose scope is
    confined to the compilation unit are used.
 
-   The transitive call site specific clobber effects are computed
+   There are two categories of information produced by this pass:
+
+   1) The addressable (TREE_ADDRESSABLE) bit and readonly
+   (TREE_READONLY) bit associated with these variables is properly set
+   based on scanning all of the code withing the compilation unit.
+
+   2) The transitive call site specific clobber effects are computed
    for the variables whose scope is contained within this compilation
    unit.
 
@@ -35,7 +41,12 @@ along with GCC; see the file COPYING3.  If not see
    side effects of each call.  In later parts of the compiler, these
    local and global sets are examined to make the call clobbering less
    traumatic, promote some statics to registers, and improve aliasing
-   information.  */
+   information.
+
+   Currently must be run after inlining decisions have been made since
+   otherwise, the local sets will not contain information that is
+   consistent with post inlined state.  The global sets are not prone
+   to this problem since they are by definition transitive.  */
 
 #include "config.h"
 #include "system.h"
@@ -59,8 +70,9 @@ along with GCC; see the file COPYING3.  If not see
 #include "diagnostic.h"
 #include "langhooks.h"
 #include "lto-streamer.h"
-#include "toplev.h"
 
+static void add_new_function (struct cgraph_node *node,
+                             void *data ATTRIBUTE_UNUSED);
 static void remove_node_data (struct cgraph_node *node,
                              void *data ATTRIBUTE_UNUSED);
 static void duplicate_node_data (struct cgraph_node *src,
@@ -87,113 +99,157 @@ struct ipa_reference_local_vars_info_d
 /* Statics that are read and written by some set of functions. The
    local ones are based on the loads and stores local to the function.
    The global ones are based on the local info as well as the
-   transitive closure of the functions that are called. */
+   transitive closure of the functions that are called.  The
+   structures are separated to allow the global structures to be
+   shared between several functions since every function within a
+   strongly connected component will have the same information.  This
+   sharing saves both time and space in the computation of the vectors
+   as well as their translation from decl_uid form to ann_uid
+   form.  */
 
 struct ipa_reference_global_vars_info_d
 {
   bitmap statics_read;
   bitmap statics_written;
-};
-
-/* Information we save about every function after ipa-reference is completted.  */
-
-struct ipa_reference_optimization_summary_d
-{
   bitmap statics_not_read;
   bitmap statics_not_written;
 };
 
 typedef struct ipa_reference_local_vars_info_d *ipa_reference_local_vars_info_t;
 typedef struct ipa_reference_global_vars_info_d *ipa_reference_global_vars_info_t;
-typedef struct ipa_reference_optimization_summary_d *ipa_reference_optimization_summary_t;
-
 struct ipa_reference_vars_info_d
 {
-  struct ipa_reference_local_vars_info_d local;
-  struct ipa_reference_global_vars_info_d global;
+  ipa_reference_local_vars_info_t local;
+  ipa_reference_global_vars_info_t global;
 };
 
 typedef struct ipa_reference_vars_info_d *ipa_reference_vars_info_t;
 
 /* This splay tree contains all of the static variables that are
-   being considered by the compilation level alias analysis.  */
-static splay_tree reference_vars_to_consider;
+   being considered by the compilation level alias analysis.  For
+   module_at_a_time compilation, this is the set of static but not
+   public variables.  Any variables that either have their address
+   taken or participate in otherwise unsavory operations are deleted
+   from this list.  */
+static GTY((param1_is(int), param2_is(tree)))
+     splay_tree reference_vars_to_consider;
+
+/* This bitmap is used to knock out the module static variables whose
+   addresses have been taken and passed around.  */
+static bitmap module_statics_escape;
+
+/* This bitmap is used to knock out the module static variables that
+   are not readonly.  */
+static bitmap module_statics_written;
 
 /* A bit is set for every module static we are considering.  This is
    ored into the local info when asm code is found that clobbers all
    memory. */
 static bitmap all_module_statics;
 
+static struct pointer_set_t *visited_nodes;
+
 /* Obstack holding bitmaps of local analysis (live from analysis to
    propagation)  */
 static bitmap_obstack local_info_obstack;
 /* Obstack holding global analysis live forever.  */
-static bitmap_obstack optimization_summary_obstack;
+static bitmap_obstack global_info_obstack;
 
 /* Holders of ipa cgraph hooks: */
+static struct cgraph_node_hook_list *function_insertion_hook_holder;
 static struct cgraph_2node_hook_list *node_duplication_hook_holder;
 static struct cgraph_node_hook_list *node_removal_hook_holder;
 
+enum initialization_status_t
+{
+  UNINITIALIZED,
+  RUNNING,
+  FINISHED
+};
+
+tree memory_identifier_string;
+
 /* Vector where the reference var infos are actually stored. */
 DEF_VEC_P (ipa_reference_vars_info_t);
 DEF_VEC_ALLOC_P (ipa_reference_vars_info_t, heap);
 static VEC (ipa_reference_vars_info_t, heap) *ipa_reference_vars_vector;
-DEF_VEC_P (ipa_reference_optimization_summary_t);
-DEF_VEC_ALLOC_P (ipa_reference_optimization_summary_t, heap);
-static VEC (ipa_reference_optimization_summary_t, heap) *ipa_reference_opt_sum_vector;
 
 /* Return the ipa_reference_vars structure starting from the cgraph NODE.  */
 static inline ipa_reference_vars_info_t
 get_reference_vars_info (struct cgraph_node *node)
 {
   if (!ipa_reference_vars_vector
-      || VEC_length (ipa_reference_vars_info_t,
-                    ipa_reference_vars_vector) <= (unsigned int) node->uid)
+      || VEC_length (ipa_reference_vars_info_t, ipa_reference_vars_vector) <= (unsigned int)node->uid)
     return NULL;
-  return VEC_index (ipa_reference_vars_info_t, ipa_reference_vars_vector,
-                   node->uid);
+  return VEC_index (ipa_reference_vars_info_t, ipa_reference_vars_vector, node->uid);
 }
 
 /* Return the ipa_reference_vars structure starting from the cgraph NODE.  */
-static inline ipa_reference_optimization_summary_t
-get_reference_optimization_summary (struct cgraph_node *node)
+static inline void
+set_reference_vars_info (struct cgraph_node *node, ipa_reference_vars_info_t info)
+{
+  if (!ipa_reference_vars_vector
+      || VEC_length (ipa_reference_vars_info_t, ipa_reference_vars_vector) <= (unsigned int)node->uid)
+     VEC_safe_grow_cleared (ipa_reference_vars_info_t, heap, ipa_reference_vars_vector, node->uid + 1);
+  VEC_replace (ipa_reference_vars_info_t, ipa_reference_vars_vector, node->uid, info);
+}
+
+/* Get a bitmap that contains all of the locally referenced static
+   variables for function FN.  */
+static ipa_reference_local_vars_info_t
+get_local_reference_vars_info (struct cgraph_node *fn)
 {
-  if (!ipa_reference_opt_sum_vector
-      || (VEC_length (ipa_reference_optimization_summary_t,
-                    ipa_reference_opt_sum_vector)
-         <= (unsigned int) node->uid))
+  ipa_reference_vars_info_t info = get_reference_vars_info (fn);
+
+  if (info)
+    return info->local;
+  else
+    /* This phase was not run.  */
     return NULL;
-  return VEC_index (ipa_reference_optimization_summary_t, ipa_reference_opt_sum_vector,
-                   node->uid);
 }
 
-/* Return the ipa_reference_vars structure starting from the cgraph NODE.  */
-static inline void
-set_reference_vars_info (struct cgraph_node *node,
-                        ipa_reference_vars_info_t info)
+/* Get a bitmap that contains all of the globally referenced static
+   variables for function FN.  */
+
+static ipa_reference_global_vars_info_t
+get_global_reference_vars_info (struct cgraph_node *fn)
 {
-  if (!ipa_reference_vars_vector
-      || VEC_length (ipa_reference_vars_info_t,
-                    ipa_reference_vars_vector) <= (unsigned int) node->uid)
-    VEC_safe_grow_cleared (ipa_reference_vars_info_t, heap,
-                          ipa_reference_vars_vector, node->uid + 1);
-  VEC_replace (ipa_reference_vars_info_t, ipa_reference_vars_vector,
-              node->uid, info);
+  ipa_reference_vars_info_t info = get_reference_vars_info (fn);
+
+  if (info)
+    return info->global;
+  else
+    /* This phase was not run.  */
+    return NULL;
 }
 
-/* Return the ipa_reference_vars structure starting from the cgraph NODE.  */
-static inline void
-set_reference_optimization_summary (struct cgraph_node *node,
-                                   ipa_reference_optimization_summary_t info)
+/* Return a bitmap indexed by VAR_DECL uid for the static variables
+   that are read during the execution of the function FN.  Returns
+   NULL if no data is available.  */
+
+bitmap
+ipa_reference_get_read_global (struct cgraph_node *fn)
 {
-  if (!ipa_reference_opt_sum_vector
-      || (VEC_length (ipa_reference_optimization_summary_t,
-                     ipa_reference_opt_sum_vector)
-         <= (unsigned int) node->uid))
-    VEC_safe_grow_cleared (ipa_reference_optimization_summary_t,
-                          heap, ipa_reference_opt_sum_vector, node->uid + 1);
-  VEC_replace (ipa_reference_optimization_summary_t,
-              ipa_reference_opt_sum_vector, node->uid, info);
+  ipa_reference_global_vars_info_t g = get_global_reference_vars_info (fn);
+  if (g)
+    return g->statics_read;
+  else
+    return NULL;
+}
+
+/* Return a bitmap indexed by VAR_DECL uid for the static variables
+   that are written during the execution of the function FN.  Note
+   that variables written may or may not be read during the function
+   call.  Returns NULL if no data is available.  */
+
+bitmap
+ipa_reference_get_written_global (struct cgraph_node *fn)
+{
+  ipa_reference_global_vars_info_t g = get_global_reference_vars_info (fn);
+  if (g)
+    return g->statics_written;
+  else
+    return NULL;
 }
 
 /* Return a bitmap indexed by_DECL_UID uid for the static variables
@@ -203,11 +259,9 @@ set_reference_optimization_summary (struct cgraph_node *node,
 bitmap
 ipa_reference_get_not_read_global (struct cgraph_node *fn)
 {
-  ipa_reference_optimization_summary_t info;
-
-  info = get_reference_optimization_summary (fn);
-  if (info)
-    return info->statics_not_read;
+  ipa_reference_global_vars_info_t g = get_global_reference_vars_info (fn);
+  if (g)
+    return g->statics_not_read;
   else
     return NULL;
 }
@@ -220,11 +274,9 @@ ipa_reference_get_not_read_global (struct cgraph_node *fn)
 bitmap
 ipa_reference_get_not_written_global (struct cgraph_node *fn)
 {
-  ipa_reference_optimization_summary_t info;
-
-  info = get_reference_optimization_summary (fn);
-  if (info)
-    return info->statics_not_written;
+  ipa_reference_global_vars_info_t g = get_global_reference_vars_info (fn);
+  if (g)
+    return g->statics_not_written;
   else
     return NULL;
 }
@@ -241,9 +293,8 @@ add_static_var (tree var)
   gcc_assert (TREE_CODE (var) == VAR_DECL);
   if (!bitmap_bit_p (all_module_statics, uid))
     {
-      if (dump_file)
-       splay_tree_insert (reference_vars_to_consider,
-                          uid, (splay_tree_value)var);
+      splay_tree_insert (reference_vars_to_consider,
+                        uid, (splay_tree_value)var);
       bitmap_set_bit (all_module_statics, uid);
     }
 }
@@ -252,11 +303,8 @@ add_static_var (tree var)
    perform compilation unit scope escape analysis.  */
 
 static inline bool
-is_proper_for_analysis (tree t)
+has_proper_scope_for_analysis (tree t)
 {
-  /* We handle only variables whose address is never taken.  */
-  if (TREE_ADDRESSABLE (t))
-    return false;
   /* If the variable has the "used" attribute, treat it as if it had a
      been touched by the devil.  */
   if (DECL_PRESERVE_P (t))
@@ -267,19 +315,192 @@ is_proper_for_analysis (tree t)
   if (TREE_THIS_VOLATILE (t))
     return false;
 
+  /* Do not care about a local automatic that is not static.  */
+  if (!TREE_STATIC (t) && !DECL_EXTERNAL (t))
+    return false;
+
+  /* FIXME: for LTO we should include PUBLIC vars too.  This is bit difficult
+     as summarie would need unsharing.  */
+  if (DECL_EXTERNAL (t) || TREE_PUBLIC (t))
+    return false;
+
   /* We cannot touch decls where the type needs constructing.  */
   if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (t)))
     return false;
 
   /* This is a variable we care about.  Check if we have seen it
      before, and if not add it the set of variables we care about.  */
-  if (all_module_statics
-      && !bitmap_bit_p (all_module_statics, DECL_UID (t)))
+  if (!bitmap_bit_p (all_module_statics, DECL_UID (t)))
     add_static_var (t);
 
   return true;
 }
 
+/* Mark tree T as having address taken.  */
+
+static void
+mark_address_taken (tree x)
+{
+  if (TREE_CODE (x) == VAR_DECL
+      && module_statics_escape && has_proper_scope_for_analysis (x))
+    bitmap_set_bit (module_statics_escape, DECL_UID (x));
+}
+
+/* Wrapper around mark_address_taken for the stmt walker.  */
+
+static bool
+mark_address (gimple stmt ATTRIBUTE_UNUSED, tree addr,
+             void *data ATTRIBUTE_UNUSED)
+{
+  addr = get_base_address (addr);
+  if (addr)
+    mark_address_taken (addr);
+  return false;
+}
+
+/* Mark load of T.  */
+
+static bool
+mark_load (gimple stmt ATTRIBUTE_UNUSED, tree t, void *data)
+{
+  ipa_reference_local_vars_info_t local = (ipa_reference_local_vars_info_t)data;
+  t = get_base_address (t);
+  if (t && TREE_CODE (t) == VAR_DECL
+      && has_proper_scope_for_analysis (t))
+    bitmap_set_bit (local->statics_read, DECL_UID (t));
+  return false;
+}
+
+/* Mark store of T.  */
+
+static bool
+mark_store (gimple stmt ATTRIBUTE_UNUSED, tree t, void *data)
+{
+  ipa_reference_local_vars_info_t local = (ipa_reference_local_vars_info_t)data;
+  t = get_base_address (t);
+  if (t && TREE_CODE (t) == VAR_DECL
+      && has_proper_scope_for_analysis (t))
+    {
+      if (local)
+       bitmap_set_bit (local->statics_written, DECL_UID (t));
+      /* Mark the write so we can tell which statics are
+        readonly.  */
+      if (module_statics_written)
+       bitmap_set_bit (module_statics_written, DECL_UID (t));
+    }
+  return false;
+}
+
+/* Look for memory clobber and set read_all/write_all if present.  */
+
+static void
+check_asm_memory_clobber (ipa_reference_local_vars_info_t local, gimple stmt)
+{
+  size_t i;
+  tree op;
+
+  for (i = 0; i < gimple_asm_nclobbers (stmt); i++)
+    {
+      op = gimple_asm_clobber_op (stmt, i);
+      if (simple_cst_equal(TREE_VALUE (op), memory_identifier_string) == 1)
+       {
+         /* Abandon all hope, ye who enter here. */
+         local->calls_read_all = true;
+         local->calls_write_all = true;
+       }
+    }
+}
+
+/* Look for external calls and set read_all/write_all correspondingly.  */
+
+static void
+check_call (ipa_reference_local_vars_info_t local, gimple stmt)
+{
+  int flags = gimple_call_flags (stmt);
+  tree callee_t = gimple_call_fndecl (stmt);
+
+  /* Process indirect calls.  All direct calles are handled at propagation
+     time.  */
+  if (!callee_t)
+    {
+      if (flags & ECF_CONST)
+       ;
+      else if (flags & ECF_PURE)
+       local->calls_read_all = true;
+      else
+       {
+         local->calls_read_all = true;
+         /* When function does not reutrn, it is safe to ignore anythign it writes
+            to, because the effect will never happen.  */
+         if ((flags & (ECF_NOTHROW | ECF_NORETURN))
+             != (ECF_NOTHROW | ECF_NORETURN))
+           local->calls_write_all = true;
+       }
+    }
+}
+
+/* TP is the part of the tree currently under the microscope.
+   WALK_SUBTREES is part of the walk_tree api but is unused here.
+   DATA is cgraph_node of the function being walked.  */
+
+static tree
+scan_stmt_for_static_refs (gimple_stmt_iterator *gsip,
+                          struct cgraph_node *fn)
+{
+  gimple stmt = gsi_stmt (*gsip);
+  ipa_reference_local_vars_info_t local = NULL;
+
+  if (is_gimple_debug (stmt))
+    return NULL;
+
+  if (fn)
+    local = get_reference_vars_info (fn)->local;
+
+  /* Look for direct loads and stores.  */
+  walk_stmt_load_store_addr_ops (stmt, local, mark_load, mark_store,
+                                mark_address);
+
+  if (is_gimple_call (stmt))
+    check_call (local, stmt);
+  else if (gimple_code (stmt) == GIMPLE_ASM)
+    check_asm_memory_clobber (local, stmt);
+
+  return NULL;
+}
+
+/* Call-back to scan variable initializers for static references.
+   Called using walk_tree.  */
+
+static tree
+scan_initializer_for_static_refs (tree *tp, int *walk_subtrees,
+                                 void *data ATTRIBUTE_UNUSED)
+{
+  tree t = *tp;
+
+  if (TREE_CODE (t) == ADDR_EXPR)
+    {
+      mark_address_taken (get_base_var (t));
+      *walk_subtrees = 0;
+    }
+  /* Save some cycles by not walking types and declaration as we
+     won't find anything useful there anyway.  */
+  else if (IS_TYPE_OR_DECL_P (*tp))
+    *walk_subtrees = 0;
+
+  return NULL;
+}
+
+/* Lookup the tree node for the static variable that has UID.  */
+static tree
+get_static_decl (int index)
+{
+  splay_tree_node stn =
+    splay_tree_lookup (reference_vars_to_consider, index);
+  if (stn)
+    return (tree)stn->value;
+  return NULL;
+}
+
 /* Lookup the tree node for the static variable that has UID and
    convert the name to a string for debugging.  */
 
@@ -312,10 +533,10 @@ propagate_bits (ipa_reference_global_vars_info_t x_global, struct cgraph_node *x
            {
              ipa_reference_vars_info_t y_info
                = get_reference_vars_info (y);
-             ipa_reference_global_vars_info_t y_global = &y_info->global;
+             ipa_reference_global_vars_info_t y_global = y_info->global;
 
              /* Calls in current cycle do not have global computed yet.  */
-             if (!y_global->statics_read)
+             if (!y_info->global)
                continue;
 
              if (x_global->statics_read
@@ -372,19 +593,49 @@ ipa_init (void)
 
   init_p = true;
 
-  if (dump_file)
-    reference_vars_to_consider = splay_tree_new (splay_tree_compare_ints, 0, 0);
+  memory_identifier_string = build_string(7, "memory");
 
-  bitmap_obstack_initialize (&local_info_obstack);
-  bitmap_obstack_initialize (&optimization_summary_obstack);
-  all_module_statics = BITMAP_ALLOC (&local_info_obstack);
+  reference_vars_to_consider =
+    splay_tree_new_ggc (splay_tree_compare_ints);
 
+  bitmap_obstack_initialize (&local_info_obstack);
+  bitmap_obstack_initialize (&global_info_obstack);
+  module_statics_escape = BITMAP_ALLOC (&local_info_obstack);
+  module_statics_written = BITMAP_ALLOC (&local_info_obstack);
+  all_module_statics = BITMAP_ALLOC (&global_info_obstack);
+
+  /* There are some shared nodes, in particular the initializers on
+     static declarations.  We do not need to scan them more than once
+     since all we would be interested in are the addressof
+     operations.  */
+  visited_nodes = pointer_set_create ();
+
+  function_insertion_hook_holder =
+      cgraph_add_function_insertion_hook (&add_new_function, NULL);
   node_removal_hook_holder =
       cgraph_add_node_removal_hook (&remove_node_data, NULL);
   node_duplication_hook_holder =
       cgraph_add_node_duplication_hook (&duplicate_node_data, NULL);
 }
 
+/* Check out the rhs of a static or global initialization VNODE to see
+   if any of them contain addressof operations.  Note that some of
+   these variables may  not even be referenced in the code in this
+   compilation unit but their right hand sides may contain references
+   to variables defined within this unit.  */
+
+static void
+analyze_variable (struct varpool_node *vnode)
+{
+  struct walk_stmt_info wi;
+  tree global = vnode->decl;
+
+  memset (&wi, 0, sizeof (wi));
+  wi.pset = visited_nodes;
+  walk_tree (&DECL_INITIAL (global), scan_initializer_for_static_refs,
+             &wi, wi.pset);
+}
+
 
 /* Set up the persistent info for FN.  */
 
@@ -393,14 +644,17 @@ init_function_info (struct cgraph_node *fn)
 {
   ipa_reference_vars_info_t info
     = XCNEW (struct ipa_reference_vars_info_d);
+  ipa_reference_local_vars_info_t l
+    = XCNEW (struct ipa_reference_local_vars_info_d);
 
   /* Add the info to the tree's annotation.  */
   set_reference_vars_info (fn, info);
 
-  info->local.statics_read = BITMAP_ALLOC (&local_info_obstack);
-  info->local.statics_written = BITMAP_ALLOC (&local_info_obstack);
+  info->local = l;
+  l->statics_read = BITMAP_ALLOC (&local_info_obstack);
+  l->statics_written = BITMAP_ALLOC (&local_info_obstack);
 
-  return &info->local;
+  return l;
 }
 
 
@@ -410,47 +664,49 @@ init_function_info (struct cgraph_node *fn)
 static void
 analyze_function (struct cgraph_node *fn)
 {
+  tree decl = fn->decl;
+  struct function *this_cfun = DECL_STRUCT_FUNCTION (decl);
+  basic_block this_block;
+#ifdef ENABLE_CHECKING
+  tree step;
+#endif
   ipa_reference_local_vars_info_t local;
-  struct ipa_ref *ref;
-  int i;
-  tree var;
-  struct cgraph_edge *ie;
 
-  local = init_function_info (fn);
-  /* Process indirect calls.  All direct calles are handled at propagation
-     time.  */
-  for (ie = fn->indirect_calls; ie; ie = ie->next_callee)
-    if (!(ie->indirect_info->ecf_flags & ECF_CONST))
-      {
-        local->calls_read_all = true;
-        if (!(ie->indirect_info->ecf_flags & ECF_PURE)
-           && ((ie->indirect_info->ecf_flags & (ECF_NOTHROW | ECF_NORETURN))
-               !=  (ECF_NOTHROW | ECF_NORETURN)))
-         local->calls_write_all = true;
-      }
-  for (i = 0; ipa_ref_list_reference_iterate (&fn->ref_list, i, ref); i++)
+  if (dump_file)
+    fprintf (dump_file, "\n local analysis of %s\n", cgraph_node_name (fn));
+
+  push_cfun (DECL_STRUCT_FUNCTION (decl));
+  current_function_decl = decl;
+
+  init_function_info (fn);
+  FOR_EACH_BB_FN (this_block, this_cfun)
     {
-      if (ref->refered_type != IPA_REF_VARPOOL)
-       continue;
-      var = ipa_ref_varpool_node (ref)->decl;
-      if (ipa_ref_varpool_node (ref)->externally_visible
-         || !ipa_ref_varpool_node (ref)->analyzed
-         || !is_proper_for_analysis (var))
-       continue;
-      switch (ref->use)
+      gimple_stmt_iterator gsi;
+      gimple phi;
+      tree op;
+      use_operand_p use;
+      ssa_op_iter iter;
+
+      /* Find the addresses taken in phi node arguments.  */
+      for (gsi = gsi_start_phis (this_block);
+          !gsi_end_p (gsi);
+          gsi_next (&gsi))
        {
-       case IPA_REF_LOAD:
-          bitmap_set_bit (local->statics_read, DECL_UID (var));
-         break;
-       case IPA_REF_STORE:
-          bitmap_set_bit (local->statics_written, DECL_UID (var));
-         break;
-       case IPA_REF_ADDR:
-         break;
+         phi = gsi_stmt (gsi);
+         FOR_EACH_PHI_ARG (use, phi, iter, SSA_OP_USE)
+           {
+             op = USE_FROM_PTR (use);
+             if (TREE_CODE (op) == ADDR_EXPR)
+               mark_address_taken (get_base_var (op));
+           }
        }
+
+      for (gsi = gsi_start_bb (this_block); !gsi_end_p (gsi); gsi_next (&gsi))
+       scan_stmt_for_static_refs (&gsi, fn);
     }
 
-  if ((flags_from_decl_or_type (fn->decl) & (ECF_NOTHROW | ECF_NORETURN))
+  local = get_reference_vars_info (fn)->local;
+  if ((flags_from_decl_or_type (decl) & (ECF_NOTHROW | ECF_NORETURN))
       == (ECF_NOTHROW | ECF_NORETURN))
     {
       local->calls_write_all = false;
@@ -462,19 +718,115 @@ analyze_function (struct cgraph_node *fn)
     BITMAP_FREE (local->statics_written);
   if (local->calls_read_all)
     BITMAP_FREE (local->statics_read);
+
+
+#ifdef ENABLE_CHECKING
+  /* Verify that all local initializers was expanded by gimplifier.  */
+  for (step = DECL_STRUCT_FUNCTION (decl)->local_decls;
+       step;
+       step = TREE_CHAIN (step))
+    {
+      tree var = TREE_VALUE (step);
+      if (TREE_CODE (var) == VAR_DECL
+         && DECL_INITIAL (var)
+         && !TREE_STATIC (var))
+       gcc_unreachable ();
+    }
+#endif
+  pop_cfun ();
+  current_function_decl = NULL;
+}
+
+/* Remove local data associated with function FN.  */
+static void
+clean_function_local_data (struct cgraph_node *fn)
+{
+  ipa_reference_vars_info_t info = get_reference_vars_info (fn);
+  ipa_reference_local_vars_info_t l = info->local;
+  if (l)
+    {
+      if (l->statics_read
+         && l->statics_read != all_module_statics)
+       BITMAP_FREE (l->statics_read);
+      if (l->statics_written
+         &&l->statics_written != all_module_statics)
+       BITMAP_FREE (l->statics_written);
+      free (l);
+      info->local = NULL;
+    }
+}
+
+/* Remove all data associated with function FN.  */
+
+static void
+clean_function (struct cgraph_node *fn)
+{
+  ipa_reference_vars_info_t info = get_reference_vars_info (fn);
+  ipa_reference_global_vars_info_t g = info->global;
+
+  clean_function_local_data (fn);
+  if (g)
+    {
+      if (g->statics_read
+         && g->statics_read != all_module_statics)
+       BITMAP_FREE (g->statics_read);
+
+      if (g->statics_written
+         && g->statics_written != all_module_statics)
+       BITMAP_FREE (g->statics_written);
+
+      if (g->statics_not_read
+         && g->statics_not_read != all_module_statics)
+       BITMAP_FREE (g->statics_not_read);
+
+      if (g->statics_not_written
+         && g->statics_not_written != all_module_statics)
+       BITMAP_FREE (g->statics_not_written);
+      free (g);
+      info->global = NULL;
+    }
+
+  free (get_reference_vars_info (fn));
+  set_reference_vars_info (fn, NULL);
+}
+
+/* Called when new function is inserted to callgraph late.  */
+static void
+add_new_function (struct cgraph_node *node, void *data ATTRIBUTE_UNUSED)
+{
+  /* There are some shared nodes, in particular the initializers on
+     static declarations.  We do not need to scan them more than once
+     since all we would be interested in are the addressof
+     operations.  */
+  analyze_function (node);
+  visited_nodes = NULL;
 }
 
 static bitmap
-copy_global_bitmap (bitmap src)
+copy_local_bitmap (bitmap src)
 {
   bitmap dst;
   if (!src)
     return NULL;
-  dst = BITMAP_ALLOC (&optimization_summary_obstack);
+  if (src == all_module_statics)
+    return all_module_statics;
+  dst = BITMAP_ALLOC (&local_info_obstack);
   bitmap_copy (dst, src);
   return dst;
 }
 
+static bitmap
+copy_global_bitmap (bitmap src)
+{
+  bitmap dst;
+  if (!src)
+    return NULL;
+  if (src == all_module_statics)
+    return all_module_statics;
+  dst = BITMAP_ALLOC (&global_info_obstack);
+  bitmap_copy (dst, src);
+  return dst;
+}
 
 /* Called when new clone is inserted to callgraph late.  */
 
@@ -482,16 +834,33 @@ static void
 duplicate_node_data (struct cgraph_node *src, struct cgraph_node *dst,
                     void *data ATTRIBUTE_UNUSED)
 {
-  ipa_reference_optimization_summary_t ginfo;
-  ipa_reference_optimization_summary_t dst_ginfo;
-
-  ginfo = get_reference_optimization_summary (src);
-  if (!ginfo)
+  ipa_reference_global_vars_info_t ginfo;
+  ipa_reference_local_vars_info_t linfo;
+  ipa_reference_global_vars_info_t dst_ginfo;
+  ipa_reference_local_vars_info_t dst_linfo;
+
+  ginfo = get_global_reference_vars_info (src);
+  linfo = get_local_reference_vars_info (src);
+  if (!linfo && !ginfo)
     return;
-  dst_ginfo = XCNEW (struct ipa_reference_optimization_summary_d);
-  set_reference_optimization_summary (dst, dst_ginfo);
-  dst_ginfo->statics_not_read = copy_global_bitmap (ginfo->statics_not_read);
-  dst_ginfo->statics_not_written = copy_global_bitmap (ginfo->statics_not_written);
+  init_function_info (dst);
+  if (linfo)
+    {
+      dst_linfo = get_local_reference_vars_info (dst);
+      dst_linfo->statics_read = copy_local_bitmap (linfo->statics_read);
+      dst_linfo->statics_written = copy_local_bitmap (linfo->statics_written);
+      dst_linfo->calls_read_all = linfo->calls_read_all;
+      dst_linfo->calls_write_all = linfo->calls_write_all;
+    }
+  if (ginfo)
+    {
+      get_reference_vars_info (dst)->global = XCNEW (struct ipa_reference_global_vars_info_d);
+      dst_ginfo = get_global_reference_vars_info (dst);
+      dst_ginfo->statics_read = copy_global_bitmap (ginfo->statics_read);
+      dst_ginfo->statics_written = copy_global_bitmap (ginfo->statics_written);
+      dst_ginfo->statics_not_read = copy_global_bitmap (ginfo->statics_not_read);
+      dst_ginfo->statics_not_written = copy_global_bitmap (ginfo->statics_not_written);
+    }
 }
 
 /* Called when node is removed.  */
@@ -499,20 +868,8 @@ duplicate_node_data (struct cgraph_node *src, struct cgraph_node *dst,
 static void
 remove_node_data (struct cgraph_node *node, void *data ATTRIBUTE_UNUSED)
 {
-  ipa_reference_optimization_summary_t ginfo;
-  ginfo = get_reference_optimization_summary (node);
-  if (ginfo)
-    {
-      if (ginfo->statics_not_read
-         && ginfo->statics_not_read != all_module_statics)
-       BITMAP_FREE (ginfo->statics_not_read);
-
-      if (ginfo->statics_not_written
-         && ginfo->statics_not_written != all_module_statics)
-       BITMAP_FREE (ginfo->statics_not_written);
-      free (ginfo);
-      set_reference_optimization_summary (node, NULL);
-    }
+  if (get_reference_vars_info (node))
+    clean_function (node);
 }
 
 /* Analyze each function in the cgraph to see which global or statics
@@ -522,18 +879,89 @@ static void
 generate_summary (void)
 {
   struct cgraph_node *node;
+  struct varpool_node *vnode;
   unsigned int index;
   bitmap_iterator bi;
+  bitmap module_statics_readonly;
   bitmap bm_temp;
 
   ipa_init ();
+  module_statics_readonly = BITMAP_ALLOC (&local_info_obstack);
   bm_temp = BITMAP_ALLOC (&local_info_obstack);
 
-  /* Process all of the functions next.  */
+  /* Process all of the variables first.  */
+  FOR_EACH_STATIC_INITIALIZER (vnode)
+    analyze_variable (vnode);
+
+  /* Process all of the functions next.
+
+     We do not want to process any of the clones so we check that this
+     is a master clone.  However, we do need to process any
+     AVAIL_OVERWRITABLE functions (these are never clones) because
+     they may cause a static variable to escape.  The code that can
+     overwrite such a function cannot access the statics because it
+     would not be in the same compilation unit.  When the analysis is
+     finished, the computed information of these AVAIL_OVERWRITABLE is
+     replaced with worst case info.
+  */
   for (node = cgraph_nodes; node; node = node->next)
-    if (node->analyzed)
+    if (cgraph_function_body_availability (node) >= AVAIL_OVERWRITABLE)
       analyze_function (node);
 
+  pointer_set_destroy (visited_nodes);
+  visited_nodes = NULL;
+
+  /* Prune out the variables that were found to behave badly
+     (i.e. have their address taken).  */
+  EXECUTE_IF_SET_IN_BITMAP (module_statics_escape, 0, index, bi)
+    {
+      splay_tree_remove (reference_vars_to_consider, index);
+    }
+
+  bitmap_and_compl_into (all_module_statics,
+                        module_statics_escape);
+
+  bitmap_and_compl (module_statics_readonly, all_module_statics,
+                   module_statics_written);
+
+  /* If the address is not taken, we can unset the addressable bit
+     on this variable.  */
+  EXECUTE_IF_SET_IN_BITMAP (all_module_statics, 0, index, bi)
+    {
+      tree var = get_static_decl (index);
+      TREE_ADDRESSABLE (var) = 0;
+      if (dump_file)
+       fprintf (dump_file, "Not TREE_ADDRESSABLE var %s\n",
+                get_static_name (index));
+    }
+
+  /* If the variable is never written, we can set the TREE_READONLY
+     flag.  Additionally if it has a DECL_INITIAL that is made up of
+     constants we can treat the entire global as a constant.  */
+
+  bitmap_and_compl (module_statics_readonly, all_module_statics,
+                   module_statics_written);
+  EXECUTE_IF_SET_IN_BITMAP (module_statics_readonly, 0, index, bi)
+    {
+      tree var = get_static_decl (index);
+
+      /* Ignore variables in named sections - changing TREE_READONLY
+        changes the section flags, potentially causing conflicts with
+        other variables in the same named section.  */
+      if (DECL_SECTION_NAME (var) == NULL_TREE)
+       {
+         TREE_READONLY (var) = 1;
+         if (dump_file)
+           fprintf (dump_file, "read-only var %s\n",
+                    get_static_name (index));
+       }
+    }
+
+  BITMAP_FREE(module_statics_escape);
+  BITMAP_FREE(module_statics_written);
+  module_statics_escape = NULL;
+  module_statics_written = NULL;
+
   if (dump_file)
     EXECUTE_IF_SET_IN_BITMAP (all_module_statics, 0, index, bi)
       {
@@ -541,6 +969,25 @@ generate_summary (void)
                 get_static_name (index));
       }
 
+  for (node = cgraph_nodes; node; node = node->next)
+    if (cgraph_function_body_availability (node) >= AVAIL_OVERWRITABLE)
+      {
+       ipa_reference_local_vars_info_t l;
+       l = get_reference_vars_info (node)->local;
+
+       /* Any variables that are not in all_module_statics are
+          removed from the local maps.  This will include all of the
+          variables that were found to escape in the function
+          scanning.  */
+       if (l->statics_read)
+         bitmap_and_into (l->statics_read,
+                          all_module_statics);
+       if (l->statics_written)
+         bitmap_and_into (l->statics_written,
+                          all_module_statics);
+      }
+
+  BITMAP_FREE(module_statics_readonly);
   BITMAP_FREE(bm_temp);
 
   if (dump_file)
@@ -551,7 +998,7 @@ generate_summary (void)
          unsigned int index;
          bitmap_iterator bi;
 
-         l = &get_reference_vars_info (node)->local;
+         l = get_reference_vars_info (node)->local;
          fprintf (dump_file,
                   "\nFunction name:%s/%i:",
                   cgraph_node_name (node), node->uid);
@@ -577,9 +1024,159 @@ generate_summary (void)
             fprintf (dump_file, "\n  calls read all: ");
        }
 }
+
+
+/* Return true if we need to write summary of NODE. */
+
+static bool
+write_node_summary_p (struct cgraph_node *node)
+{
+  gcc_assert (node->global.inlined_to == NULL);
+  return (node->analyzed
+         && cgraph_function_body_availability (node) >= AVAIL_OVERWRITABLE
+         && get_reference_vars_info (node) != NULL);
+}
+
+/* Serialize the ipa info for lto.  */
+
+static void
+ipa_reference_write_summary (cgraph_node_set set)
+{
+  struct cgraph_node *node;
+  struct lto_simple_output_block *ob
+    = lto_create_simple_output_block (LTO_section_ipa_reference);
+  unsigned int count = 0;
+  cgraph_node_set_iterator csi;
+
+  for (csi = csi_start (set); !csi_end_p (csi); csi_next (&csi))
+    if (write_node_summary_p (csi_node (csi)))
+       count++;
+
+  lto_output_uleb128_stream (ob->main_stream, count);
+
+  /* Process all of the functions.  */
+  for (csi = csi_start (set); !csi_end_p (csi); csi_next (&csi))
+    {
+      node = csi_node (csi);
+      if (write_node_summary_p (node))
+       {
+         ipa_reference_local_vars_info_t l
+           = get_reference_vars_info (node)->local;
+         unsigned int index;
+         bitmap_iterator bi;
+         lto_cgraph_encoder_t encoder;
+         int node_ref;
+
+         encoder = ob->decl_state->cgraph_node_encoder;
+         node_ref = lto_cgraph_encoder_encode (encoder, node);
+         lto_output_uleb128_stream (ob->main_stream, node_ref);
+
+         /* Stream out the statics read.  */
+         if (l->calls_read_all)
+           lto_output_sleb128_stream (ob->main_stream, -1);
+         else
+           {
+             lto_output_sleb128_stream (ob->main_stream,
+                                        bitmap_count_bits (l->statics_read));
+             EXECUTE_IF_SET_IN_BITMAP (l->statics_read, 0, index, bi)
+               lto_output_var_decl_index(ob->decl_state, ob->main_stream,
+                                         get_static_decl (index));
+           }
+
+         /* Stream out the statics written.  */
+         if (l->calls_write_all)
+           lto_output_sleb128_stream (ob->main_stream, -1);
+         else
+           {
+             lto_output_sleb128_stream (ob->main_stream,
+                                        bitmap_count_bits (l->statics_written));
+             EXECUTE_IF_SET_IN_BITMAP (l->statics_written, 0, index, bi)
+               lto_output_var_decl_index(ob->decl_state, ob->main_stream,
+                                         get_static_decl (index));
+           }
+       }
+    }
+  lto_destroy_simple_output_block (ob);
+}
+
+
+/* Deserialize the ipa info for lto.  */
+
+static void
+ipa_reference_read_summary (void)
+{
+  struct lto_file_decl_data ** file_data_vec
+    = lto_get_file_decl_data ();
+  struct lto_file_decl_data * file_data;
+  unsigned int j = 0;
+
+  ipa_init ();
+
+  while ((file_data = file_data_vec[j++]))
+    {
+      const char *data;
+      size_t len;
+      struct lto_input_block *ib
+       = lto_create_simple_input_block (file_data,
+                                        LTO_section_ipa_reference,
+                                        &data, &len);
+      if (ib)
+       {
+         unsigned int i;
+         unsigned int f_count = lto_input_uleb128 (ib);
+
+         for (i = 0; i < f_count; i++)
+           {
+             unsigned int j, index;
+             struct cgraph_node *node;
+             ipa_reference_local_vars_info_t l;
+             int v_count;
+             lto_cgraph_encoder_t encoder;
+
+             index = lto_input_uleb128 (ib);
+             encoder = file_data->cgraph_node_encoder;
+             node = lto_cgraph_encoder_deref (encoder, index);
+             l = init_function_info (node);
+
+             /* Set the statics read.  */
+             v_count = lto_input_sleb128 (ib);
+             if (v_count == -1)
+               l->calls_read_all = true;
+             else
+               for (j = 0; j < (unsigned int)v_count; j++)
+                 {
+                   unsigned int var_index = lto_input_uleb128 (ib);
+                   tree v_decl = lto_file_decl_data_get_var_decl (file_data,
+                                                                  var_index);
+                   add_static_var (v_decl);
+                   bitmap_set_bit (l->statics_read, DECL_UID (v_decl));
+                 }
+
+             /* Set the statics written.  */
+             v_count = lto_input_sleb128 (ib);
+             if (v_count == -1)
+               l->calls_write_all = true;
+             else
+               for (j = 0; j < (unsigned int)v_count; j++)
+                 {
+                   unsigned int var_index = lto_input_uleb128 (ib);
+                   tree v_decl = lto_file_decl_data_get_var_decl (file_data,
+                                                                  var_index);
+                   add_static_var (v_decl);
+                   bitmap_set_bit (l->statics_written, DECL_UID (v_decl));
+                 }
+           }
+
+         lto_destroy_simple_input_block (file_data,
+                                         LTO_section_ipa_reference,
+                                         ib, data, len);
+       }
+    }
+}
+
+
 \f
 /* Set READ_ALL/WRITE_ALL based on DECL flags.  */
-
 static void
 read_write_all_from_decl (tree decl, bool * read_all, bool * write_all)
 {
@@ -591,9 +1188,11 @@ read_write_all_from_decl (tree decl, bool * read_all, bool * write_all)
   else
     {
        /* TODO: To be able to produce sane results, we should also handle
-         common builtins, in particular throw.  */
+         common builtins, in particular throw.
+         Indirect calls hsould be only counted and as inliner is replacing them
+         by direct calls, we can conclude if any indirect calls are left in body */
       *read_all = true;
-      /* When function does not return, it is safe to ignore anythign it writes
+      /* When function does not reutrn, it is safe to ignore anythign it writes
         to, because the effect will never happen.  */
       if ((flags & (ECF_NOTHROW | ECF_NORETURN))
          != (ECF_NOTHROW | ECF_NORETURN))
@@ -602,7 +1201,8 @@ read_write_all_from_decl (tree decl, bool * read_all, bool * write_all)
 }
 
 /* Produce the global information by preforming a transitive closure
-   on the local information that was produced by ipa_analyze_function */
+   on the local information that was produced by ipa_analyze_function
+   and ipa_analyze_variable.  */
 
 static unsigned int
 propagate (void)
@@ -614,12 +1214,10 @@ propagate (void)
   int order_pos = ipa_utils_reduced_inorder (order, false, true, NULL);
   int i;
 
+  cgraph_remove_function_insertion_hook (function_insertion_hook_holder);
   if (dump_file)
     dump_cgraph (dump_file);
 
-  ipa_discover_readonly_nonaddressable_vars ();
-  generate_summary ();
-
   /* Propagate the local information thru the call graph to produce
      the global information.  All the nodes within a cycle will have
      the same info so we collapse cycles first.  Then we can do the
@@ -631,7 +1229,8 @@ propagate (void)
   for (i = 0; i < order_pos; i++ )
     {
       ipa_reference_vars_info_t node_info;
-      ipa_reference_global_vars_info_t node_g;
+      ipa_reference_global_vars_info_t node_g =
+       XCNEW (struct ipa_reference_global_vars_info_d);
       ipa_reference_local_vars_info_t node_l;
       struct cgraph_edge *e;
 
@@ -648,8 +1247,8 @@ propagate (void)
          gcc_unreachable ();
        }
 
-      node_l = &node_info->local;
-      node_g = &node_info->global;
+      gcc_assert (!node_info->global);
+      node_l = node_info->local;
 
       read_all = node_l->calls_read_all;
       write_all = node_l->calls_write_all;
@@ -670,7 +1269,7 @@ propagate (void)
       while (w)
        {
          ipa_reference_local_vars_info_t w_l =
-           &get_reference_vars_info (w)->local;
+           get_reference_vars_info (w)->local;
 
          /* When function is overwrittable, we can not assume anything.  */
          if (cgraph_function_body_availability (w) <= AVAIL_OVERWRITABLE)
@@ -693,7 +1292,7 @@ propagate (void)
        node_g->statics_read = all_module_statics;
       else
        {
-         node_g->statics_read = BITMAP_ALLOC (&local_info_obstack);
+         node_g->statics_read = BITMAP_ALLOC (&global_info_obstack);
          bitmap_copy (node_g->statics_read,
                       node_l->statics_read);
        }
@@ -701,7 +1300,7 @@ propagate (void)
        node_g->statics_written = all_module_statics;
       else
        {
-         node_g->statics_written = BITMAP_ALLOC (&local_info_obstack);
+         node_g->statics_written = BITMAP_ALLOC (&global_info_obstack);
          bitmap_copy (node_g->statics_written,
                       node_l->statics_written);
        }
@@ -713,7 +1312,7 @@ propagate (void)
        {
          ipa_reference_vars_info_t w_ri =
            get_reference_vars_info (w);
-         ipa_reference_local_vars_info_t w_l = &w_ri->local;
+         ipa_reference_local_vars_info_t w_l = w_ri->local;
 
          /* These global bitmaps are initialized from the local info
             of all of the nodes in the region.  However there is no
@@ -731,7 +1330,7 @@ propagate (void)
        }
 
       /* All nodes within a cycle have the same global info bitmaps.  */
-      node_info->global = *node_g;
+      node_info->global = node_g;
       w_info = (struct ipa_dfs_info *) node->aux;
       w = w_info->next_cycle;
       while (w)
@@ -739,7 +1338,10 @@ propagate (void)
          ipa_reference_vars_info_t w_ri =
            get_reference_vars_info (w);
 
-          w_ri->global = *node_g;
+         gcc_assert (!w_ri->global);
+          w_ri->global = XCNEW (struct ipa_reference_global_vars_info_d);
+         w_ri->global->statics_read = copy_global_bitmap (node_g->statics_read);
+         w_ri->global->statics_written = copy_global_bitmap (node_g->statics_written);
 
          w_info = (struct ipa_dfs_info *) w->aux;
          w = w_info->next_cycle;
@@ -759,8 +1361,8 @@ propagate (void)
 
          node = order[i];
          node_info = get_reference_vars_info (node);
-         node_g = &node_info->global;
-         node_l = &node_info->local;
+         node_g = node_info->global;
+         node_l = node_info->local;
          fprintf (dump_file,
                   "\nFunction name:%s/%i:",
                   cgraph_node_name (node), node->uid);
@@ -787,7 +1389,7 @@ propagate (void)
            {
              ipa_reference_vars_info_t w_ri =
                get_reference_vars_info (w);
-             ipa_reference_local_vars_info_t w_l = &w_ri->local;
+             ipa_reference_local_vars_info_t w_l = w_ri->local;
              fprintf (dump_file, "\n  next cycle: %s/%i ",
                       cgraph_node_name (w), w->uid);
              fprintf (dump_file, "\n    locals read: ");
@@ -835,261 +1437,54 @@ propagate (void)
     }
 
   /* Cleanup. */
-  for (node = cgraph_nodes; node; node = node->next)
+  for (i = 0; i < order_pos; i++ )
     {
       ipa_reference_vars_info_t node_info;
       ipa_reference_global_vars_info_t node_g;
-      ipa_reference_optimization_summary_t opt;
-
-      if (!node->analyzed)
-        continue;
-
+      node = order[i];
       node_info = get_reference_vars_info (node);
-      if (cgraph_function_body_availability (node) > AVAIL_OVERWRITABLE)
-       {
-         node_g = &node_info->global;
-
-         opt = XCNEW (struct ipa_reference_optimization_summary_d);
-         set_reference_optimization_summary (node, opt);
+      node_g = node_info->global;
+
+      /* Create the complimentary sets.  These are more useful for
+        certain apis.  */
+      node_g->statics_not_read = BITMAP_ALLOC (&global_info_obstack);
+      node_g->statics_not_written = BITMAP_ALLOC (&global_info_obstack);
+
+      if (node_g->statics_read != all_module_statics)
+       bitmap_and_compl (node_g->statics_not_read,
+                         all_module_statics,
+                         node_g->statics_read);
+
+      if (node_g->statics_written
+         != all_module_statics)
+       bitmap_and_compl (node_g->statics_not_written,
+                         all_module_statics,
+                         node_g->statics_written);
+   }
 
-         /* Create the complimentary sets.  */
-         opt->statics_not_read = BITMAP_ALLOC (&optimization_summary_obstack);
-         opt->statics_not_written = BITMAP_ALLOC (&optimization_summary_obstack);
+  free (order);
 
-         if (node_g->statics_read != all_module_statics)
-           bitmap_and_compl (opt->statics_not_read,
-                             all_module_statics,
-                             node_g->statics_read);
+  for (node = cgraph_nodes; node; node = node->next)
+    {
+      ipa_reference_vars_info_t node_info;
+      node_info = get_reference_vars_info (node);
+      /* Get rid of the aux information.  */
 
-         if (node_g->statics_written
-             != all_module_statics)
-           bitmap_and_compl (opt->statics_not_written,
-                             all_module_statics,
-                             node_g->statics_written);
-       }
-      if (node_info)
-       free (node_info);
       if (node->aux)
        {
          free (node->aux);
          node->aux = NULL;
        }
-   }
-
-  free (order);
 
+      if (cgraph_function_body_availability (node) == AVAIL_OVERWRITABLE)
+       clean_function (node);
+      else if (node_info)
+       clean_function_local_data (node);
+    }
   bitmap_obstack_release (&local_info_obstack);
-  VEC_free (ipa_reference_vars_info_t, heap, ipa_reference_vars_vector);
-  ipa_reference_vars_vector = NULL;
-  if (dump_file)
-    splay_tree_delete (reference_vars_to_consider);
-  reference_vars_to_consider = NULL;
-  all_module_statics = NULL;
   return 0;
 }
 
-/* Return true if we need to write summary of NODE. */
-
-static bool
-write_node_summary_p (struct cgraph_node *node,
-                     cgraph_node_set set,
-                     varpool_node_set vset,
-                     bitmap ltrans_statics)
-{
-  ipa_reference_optimization_summary_t info;
-
-  /* See if we have (non-empty) info.  */
-  if (!node->analyzed || node->global.inlined_to)
-    return false;
-  info = get_reference_optimization_summary (node);
-  if (!info || (bitmap_empty_p (info->statics_not_read)
-               && bitmap_empty_p (info->statics_not_written)))
-    return false;
-
-  /* See if we want to encode it.
-     Encode also referenced functions since constant folding might turn it into
-     a direct call.
-
-     In future we might also want to include summaries of functions references
-     by initializers of constant variables references in current unit.  */
-  if (!reachable_from_this_partition_p (node, set)
-      && !referenced_from_this_partition_p (&node->ref_list, set, vset))
-    return false;
-
-  /* See if the info has non-empty intersections with vars we want to encode.  */
-  if (!bitmap_intersect_p (info->statics_not_read, ltrans_statics)
-      && !bitmap_intersect_p (info->statics_not_written, ltrans_statics))
-    return false;
-  return true;
-}
-
-/* Stream out BITS&LTRANS_STATICS as list of decls to OB.  */
-
-static void
-stream_out_bitmap (struct lto_simple_output_block *ob,
-                  bitmap bits, bitmap ltrans_statics)
-{
-  unsigned int count = 0;
-  unsigned int index;
-  bitmap_iterator bi;
-  EXECUTE_IF_AND_IN_BITMAP (bits, ltrans_statics, 0, index, bi)
-    count ++;
-  lto_output_uleb128_stream (ob->main_stream, count);
-  if (!count)
-    return;
-  EXECUTE_IF_AND_IN_BITMAP (bits, ltrans_statics, 0, index, bi)
-    {
-      tree decl = (tree)splay_tree_lookup (reference_vars_to_consider, index)->value;
-      lto_output_var_decl_index(ob->decl_state, ob->main_stream, decl);
-    }
-}
-
-/* Serialize the ipa info for lto.  */
-
-static void
-ipa_reference_write_optimization_summary (cgraph_node_set set,
-                                         varpool_node_set vset)
-{
-  struct cgraph_node *node;
-  struct varpool_node *vnode;
-  struct lto_simple_output_block *ob
-    = lto_create_simple_output_block (LTO_section_ipa_reference);
-  unsigned int count = 0;
-  lto_cgraph_encoder_t encoder = ob->decl_state->cgraph_node_encoder;
-  bitmap ltrans_statics = BITMAP_ALLOC (NULL);
-
-  reference_vars_to_consider = splay_tree_new (splay_tree_compare_ints, 0, 0);
-
-  /* See what variables we are interested in.  */
-  for (vnode = varpool_nodes; vnode; vnode = vnode->next)
-    if (referenced_from_this_partition_p (&vnode->ref_list, set, vset))
-      {
-       tree decl = vnode->decl;
-       if (is_proper_for_analysis (decl))
-         {
-           bitmap_set_bit (ltrans_statics, DECL_UID (decl));
-           splay_tree_insert (reference_vars_to_consider,
-                              DECL_UID (decl), (splay_tree_value)decl);
-         }
-      }
-
-  for (node = cgraph_nodes; node; node = node->next)
-    if (write_node_summary_p (node, set, vset, ltrans_statics))
-       count++;
-
-  lto_output_uleb128_stream (ob->main_stream, count);
-
-  /* Process all of the functions.  */
-  for (node = cgraph_nodes; node; node = node->next)
-    if (write_node_summary_p (node, set, vset, ltrans_statics))
-      {
-       ipa_reference_optimization_summary_t info;
-       int node_ref;
-
-       info = get_reference_optimization_summary (node);
-       node_ref = lto_cgraph_encoder_encode (encoder, node);
-       lto_output_uleb128_stream (ob->main_stream, node_ref);
-
-       stream_out_bitmap (ob, info->statics_not_read, ltrans_statics);
-       stream_out_bitmap (ob, info->statics_not_written, ltrans_statics);
-      }
-  BITMAP_FREE (ltrans_statics);
-  lto_destroy_simple_output_block (ob);
-  splay_tree_delete (reference_vars_to_consider);
-}
-
-/* Deserialize the ipa info for lto.  */
-
-static void
-ipa_reference_read_optimization_summary (void)
-{
-  struct lto_file_decl_data ** file_data_vec
-    = lto_get_file_decl_data ();
-  struct lto_file_decl_data * file_data;
-  unsigned int j = 0;
-  bitmap_obstack_initialize (&optimization_summary_obstack);
-
-  node_removal_hook_holder =
-      cgraph_add_node_removal_hook (&remove_node_data, NULL);
-  node_duplication_hook_holder =
-      cgraph_add_node_duplication_hook (&duplicate_node_data, NULL);
-
-  while ((file_data = file_data_vec[j++]))
-    {
-      const char *data;
-      size_t len;
-      struct lto_input_block *ib
-       = lto_create_simple_input_block (file_data,
-                                        LTO_section_ipa_reference,
-                                        &data, &len);
-      if (ib)
-       {
-         unsigned int i;
-         unsigned int f_count = lto_input_uleb128 (ib);
-
-         for (i = 0; i < f_count; i++)
-           {
-             unsigned int j, index;
-             struct cgraph_node *node;
-             ipa_reference_optimization_summary_t info;
-             int v_count;
-             lto_cgraph_encoder_t encoder;
-
-             index = lto_input_uleb128 (ib);
-             encoder = file_data->cgraph_node_encoder;
-             node = lto_cgraph_encoder_deref (encoder, index);
-             info = XCNEW (struct ipa_reference_optimization_summary_d);
-             set_reference_optimization_summary (node, info);
-             info->statics_not_read = BITMAP_ALLOC (&optimization_summary_obstack);
-             info->statics_not_written = BITMAP_ALLOC (&optimization_summary_obstack);
-             if (dump_file)
-               fprintf (dump_file,
-                        "\nFunction name:%s/%i:\n  static not read:",
-                        cgraph_node_name (node), node->uid);
-
-             /* Set the statics not read.  */
-             v_count = lto_input_uleb128 (ib);
-             for (j = 0; j < (unsigned int)v_count; j++)
-               {
-                 unsigned int var_index = lto_input_uleb128 (ib);
-                 tree v_decl = lto_file_decl_data_get_var_decl (file_data,
-                                                                var_index);
-                 bitmap_set_bit (info->statics_not_read, DECL_UID (v_decl));
-                 if (dump_file)
-                   fprintf (dump_file, " %s",
-                            lang_hooks.decl_printable_name (v_decl, 2));
-               }
-
-             if (dump_file)
-               fprintf (dump_file,
-                        "\n  static not written:");
-             /* Set the statics not written.  */
-             v_count = lto_input_uleb128 (ib);
-             for (j = 0; j < (unsigned int)v_count; j++)
-               {
-                 unsigned int var_index = lto_input_uleb128 (ib);
-                 tree v_decl = lto_file_decl_data_get_var_decl (file_data,
-                                                                var_index);
-                 bitmap_set_bit (info->statics_not_written, DECL_UID (v_decl));
-                 if (dump_file)
-                   fprintf (dump_file, " %s",
-                            lang_hooks.decl_printable_name (v_decl, 2));
-               }
-             if (dump_file)
-               fprintf (dump_file, "\n");
-           }
-
-         lto_destroy_simple_input_block (file_data,
-                                         LTO_section_ipa_reference,
-                                         ib, data, len);
-       }
-      else
-       /* Fatal error here.  We do not want to support compiling ltrans units with
-          different version of compiler or different flags than the WPA unit, so
-          this should never happen.  */
-       fatal_error ("ipa reference summary is missing in ltrans unit");
-    }
-}
 
 static bool
 gate_reference (void)
@@ -1116,13 +1511,14 @@ struct ipa_opt_pass_d pass_ipa_reference =
   0,                                   /* todo_flags_start */
   0                                     /* todo_flags_finish */
  },
- NULL,                                 /* generate_summary */
- NULL,                                 /* write_summary */
- NULL,                                 /* read_summary */
- ipa_reference_write_optimization_summary,/* write_optimization_summary */
- ipa_reference_read_optimization_summary,/* read_optimization_summary */
+ generate_summary,                     /* generate_summary */
+ ipa_reference_write_summary,          /* write_summary */
+ ipa_reference_read_summary,           /* read_summary */
+ NULL,                                 /* function_read_summary */
  NULL,                                 /* stmt_fixup */
  0,                                    /* TODOs */
  NULL,                                 /* function_transform */
  NULL                                  /* variable_transform */
 };
+
+#include "gt-ipa-reference.h"
index d4a7a31..f0106eb 100644 (file)
@@ -191,14 +191,14 @@ along with GCC; see the file COPYING3.  If not see
 #include "tm.h"
 #include "tree.h"
 #include "flags.h"
+#include "rtl.h"
 #include "tm_p.h"
+#include "ggc.h"
 #include "basic-block.h"
 #include "output.h"
 #include "expr.h"
 #include "function.h"
 #include "diagnostic.h"
-#include "tree-pretty-print.h"
-#include "gimple-pretty-print.h"
 #include "timevar.h"
 #include "tree-dump.h"
 #include "tree-flow.h"
@@ -269,6 +269,50 @@ debug_lattice_value (prop_value_t val)
 }
 
 
+
+/* If SYM is a constant variable with known value, return the value.
+   NULL_TREE is returned otherwise.  */
+
+tree
+get_symbol_constant_value (tree sym)
+{
+  if (TREE_STATIC (sym)
+      && (TREE_READONLY (sym)
+         || TREE_CODE (sym) == CONST_DECL))
+    {
+      tree val = DECL_INITIAL (sym);
+      if (val)
+       {
+         STRIP_NOPS (val);
+         if (is_gimple_min_invariant (val))
+           {
+             if (TREE_CODE (val) == ADDR_EXPR)
+               {
+                 tree base = get_base_address (TREE_OPERAND (val, 0));
+                 if (base && TREE_CODE (base) == VAR_DECL)
+                   {
+                     TREE_ADDRESSABLE (base) = 1;
+                     if (gimple_referenced_vars (cfun))
+                       add_referenced_var (base);
+                   }
+               }
+             return val;
+           }
+       }
+      /* Variables declared 'const' without an initializer
+        have zero as the initializer if they may not be
+        overridden at link or run time.  */
+      if (!val
+         && !DECL_EXTERNAL (sym)
+         && targetm.binds_local_p (sym)
+          && (INTEGRAL_TYPE_P (TREE_TYPE (sym))
+              || SCALAR_FLOAT_TYPE_P (TREE_TYPE (sym))))
+       return fold_convert (TREE_TYPE (sym), integer_zero_node);
+    }
+
+  return NULL_TREE;
+}
+
 /* Compute a default value for variable VAR and store it in the
    CONST_VAL array.  The following rules are used to get default
    values:
@@ -841,6 +885,36 @@ ccp_visit_phi_node (gimple phi)
     return SSA_PROP_NOT_INTERESTING;
 }
 
+/* Return true if we may propagate the address expression ADDR into the
+   dereference DEREF and cancel them.  */
+
+bool
+may_propagate_address_into_dereference (tree addr, tree deref)
+{
+  gcc_assert (INDIRECT_REF_P (deref)
+             && TREE_CODE (addr) == ADDR_EXPR);
+
+  /* Don't propagate if ADDR's operand has incomplete type.  */
+  if (!COMPLETE_TYPE_P (TREE_TYPE (TREE_OPERAND (addr, 0))))
+    return false;
+
+  /* If the address is invariant then we do not need to preserve restrict
+     qualifications.  But we do need to preserve volatile qualifiers until
+     we can annotate the folded dereference itself properly.  */
+  if (is_gimple_min_invariant (addr)
+      && (!TREE_THIS_VOLATILE (deref)
+         || TYPE_VOLATILE (TREE_TYPE (addr))))
+    return useless_type_conversion_p (TREE_TYPE (deref),
+                                     TREE_TYPE (TREE_OPERAND (addr, 0)));
+
+  /* Else both the address substitution and the folding must result in
+     a valid useless type conversion sequence.  */
+  return (useless_type_conversion_p (TREE_TYPE (TREE_OPERAND (deref, 0)),
+                                    TREE_TYPE (addr))
+         && useless_type_conversion_p (TREE_TYPE (deref),
+                                       TREE_TYPE (TREE_OPERAND (addr, 0))));
+}
+
 /* CCP specific front-end to the non-destructive constant folding
    routines.
 
@@ -1697,6 +1771,1410 @@ struct gimple_opt_pass pass_ccp =
 };
 
 
+/* A subroutine of fold_stmt.  Attempts to fold *(A+O) to A[X].
+   BASE is an array type.  OFFSET is a byte displacement.  ORIG_TYPE
+   is the desired result type.
+
+   LOC is the location of the original expression.  */
+
+static tree
+maybe_fold_offset_to_array_ref (location_t loc, tree base, tree offset,
+                               tree orig_type,
+                               bool allow_negative_idx)
+{
+  tree min_idx, idx, idx_type, elt_offset = integer_zero_node;
+  tree array_type, elt_type, elt_size;
+  tree domain_type;
+
+  /* If BASE is an ARRAY_REF, we can pick up another offset (this time
+     measured in units of the size of elements type) from that ARRAY_REF).
+     We can't do anything if either is variable.
+
+     The case we handle here is *(&A[N]+O).  */
+  if (TREE_CODE (base) == ARRAY_REF)
+    {
+      tree low_bound = array_ref_low_bound (base);
+
+      elt_offset = TREE_OPERAND (base, 1);
+      if (TREE_CODE (low_bound) != INTEGER_CST
+         || TREE_CODE (elt_offset) != INTEGER_CST)
+       return NULL_TREE;
+
+      elt_offset = int_const_binop (MINUS_EXPR, elt_offset, low_bound, 0);
+      base = TREE_OPERAND (base, 0);
+    }
+
+  /* Ignore stupid user tricks of indexing non-array variables.  */
+  array_type = TREE_TYPE (base);
+  if (TREE_CODE (array_type) != ARRAY_TYPE)
+    return NULL_TREE;
+  elt_type = TREE_TYPE (array_type);
+  if (!useless_type_conversion_p (orig_type, elt_type))
+    return NULL_TREE;
+
+  /* Use signed size type for intermediate computation on the index.  */
+  idx_type = signed_type_for (size_type_node);
+
+  /* If OFFSET and ELT_OFFSET are zero, we don't care about the size of the
+     element type (so we can use the alignment if it's not constant).
+     Otherwise, compute the offset as an index by using a division.  If the
+     division isn't exact, then don't do anything.  */
+  elt_size = TYPE_SIZE_UNIT (elt_type);
+  if (!elt_size)
+    return NULL;
+  if (integer_zerop (offset))
+    {
+      if (TREE_CODE (elt_size) != INTEGER_CST)
+       elt_size = size_int (TYPE_ALIGN (elt_type));
+
+      idx = build_int_cst (idx_type, 0);
+    }
+  else
+    {
+      unsigned HOST_WIDE_INT lquo, lrem;
+      HOST_WIDE_INT hquo, hrem;
+      double_int soffset;
+
+      /* The final array offset should be signed, so we need
+        to sign-extend the (possibly pointer) offset here
+        and use signed division.  */
+      soffset = double_int_sext (tree_to_double_int (offset),
+                                TYPE_PRECISION (TREE_TYPE (offset)));
+      if (TREE_CODE (elt_size) != INTEGER_CST
+         || div_and_round_double (TRUNC_DIV_EXPR, 0,
+                                  soffset.low, soffset.high,
+                                  TREE_INT_CST_LOW (elt_size),
+                                  TREE_INT_CST_HIGH (elt_size),
+                                  &lquo, &hquo, &lrem, &hrem)
+         || lrem || hrem)
+       return NULL_TREE;
+
+      idx = build_int_cst_wide (idx_type, lquo, hquo);
+    }
+
+  /* Assume the low bound is zero.  If there is a domain type, get the
+     low bound, if any, convert the index into that type, and add the
+     low bound.  */
+  min_idx = build_int_cst (idx_type, 0);
+  domain_type = TYPE_DOMAIN (array_type);
+  if (domain_type)
+    {
+      idx_type = domain_type;
+      if (TYPE_MIN_VALUE (idx_type))
+       min_idx = TYPE_MIN_VALUE (idx_type);
+      else
+       min_idx = fold_convert (idx_type, min_idx);
+
+      if (TREE_CODE (min_idx) != INTEGER_CST)
+       return NULL_TREE;
+
+      elt_offset = fold_convert (idx_type, elt_offset);
+    }
+
+  if (!integer_zerop (min_idx))
+    idx = int_const_binop (PLUS_EXPR, idx, min_idx, 0);
+  if (!integer_zerop (elt_offset))
+    idx = int_const_binop (PLUS_EXPR, idx, elt_offset, 0);
+
+  /* Make sure to possibly truncate late after offsetting.  */
+  idx = fold_convert (idx_type, idx);
+
+  /* We don't want to construct access past array bounds. For example
+       char *(c[4]);
+       c[3][2];
+     should not be simplified into (*c)[14] or tree-vrp will
+     give false warnings.  The same is true for
+       struct A { long x; char d[0]; } *a;
+       (char *)a - 4;
+     which should be not folded to &a->d[-8].  */
+  if (domain_type
+      && TYPE_MAX_VALUE (domain_type)
+      && TREE_CODE (TYPE_MAX_VALUE (domain_type)) == INTEGER_CST)
+    {
+      tree up_bound = TYPE_MAX_VALUE (domain_type);
+
+      if (tree_int_cst_lt (up_bound, idx)
+         /* Accesses after the end of arrays of size 0 (gcc
+            extension) and 1 are likely intentional ("struct
+            hack").  */
+         && compare_tree_int (up_bound, 1) > 0)
+       return NULL_TREE;
+    }
+  if (domain_type
+      && TYPE_MIN_VALUE (domain_type))
+    {
+      if (!allow_negative_idx
+         && TREE_CODE (TYPE_MIN_VALUE (domain_type)) == INTEGER_CST
+         && tree_int_cst_lt (idx, TYPE_MIN_VALUE (domain_type)))
+       return NULL_TREE;
+    }
+  else if (!allow_negative_idx
+          && compare_tree_int (idx, 0) < 0)
+    return NULL_TREE;
+
+  {
+    tree t = build4 (ARRAY_REF, elt_type, base, idx, NULL_TREE, NULL_TREE);
+    SET_EXPR_LOCATION (t, loc);
+    return t;
+  }
+}
+
+
+/* Attempt to fold *(S+O) to S.X.
+   BASE is a record type.  OFFSET is a byte displacement.  ORIG_TYPE
+   is the desired result type.
+
+   LOC is the location of the original expression.  */
+
+static tree
+maybe_fold_offset_to_component_ref (location_t loc, tree record_type,
+                                   tree base, tree offset, tree orig_type)
+{
+  tree f, t, field_type, tail_array_field, field_offset;
+  tree ret;
+  tree new_base;
+
+  if (TREE_CODE (record_type) != RECORD_TYPE
+      && TREE_CODE (record_type) != UNION_TYPE
+      && TREE_CODE (record_type) != QUAL_UNION_TYPE)
+    return NULL_TREE;
+
+  /* Short-circuit silly cases.  */
+  if (useless_type_conversion_p (record_type, orig_type))
+    return NULL_TREE;
+
+  tail_array_field = NULL_TREE;
+  for (f = TYPE_FIELDS (record_type); f ; f = TREE_CHAIN (f))
+    {
+      int cmp;
+
+      if (TREE_CODE (f) != FIELD_DECL)
+       continue;
+      if (DECL_BIT_FIELD (f))
+       continue;
+
+      if (!DECL_FIELD_OFFSET (f))
+       continue;
+      field_offset = byte_position (f);
+      if (TREE_CODE (field_offset) != INTEGER_CST)
+       continue;
+
+      /* ??? Java creates "interesting" fields for representing base classes.
+        They have no name, and have no context.  With no context, we get into
+        trouble with nonoverlapping_component_refs_p.  Skip them.  */
+      if (!DECL_FIELD_CONTEXT (f))
+       continue;
+
+      /* The previous array field isn't at the end.  */
+      tail_array_field = NULL_TREE;
+
+      /* Check to see if this offset overlaps with the field.  */
+      cmp = tree_int_cst_compare (field_offset, offset);
+      if (cmp > 0)
+       continue;
+
+      field_type = TREE_TYPE (f);
+
+      /* Here we exactly match the offset being checked.  If the types match,
+        then we can return that field.  */
+      if (cmp == 0
+         && useless_type_conversion_p (orig_type, field_type))
+       {
+         t = build3 (COMPONENT_REF, field_type, base, f, NULL_TREE);
+         return t;
+       }
+
+      /* Don't care about offsets into the middle of scalars.  */
+      if (!AGGREGATE_TYPE_P (field_type))
+       continue;
+
+      /* Check for array at the end of the struct.  This is often
+        used as for flexible array members.  We should be able to
+        turn this into an array access anyway.  */
+      if (TREE_CODE (field_type) == ARRAY_TYPE)
+       tail_array_field = f;
+
+      /* Check the end of the field against the offset.  */
+      if (!DECL_SIZE_UNIT (f)
+         || TREE_CODE (DECL_SIZE_UNIT (f)) != INTEGER_CST)
+       continue;
+      t = int_const_binop (MINUS_EXPR, offset, field_offset, 1);
+      if (!tree_int_cst_lt (t, DECL_SIZE_UNIT (f)))
+       continue;
+
+      /* If we matched, then set offset to the displacement into
+        this field.  */
+      new_base = build3 (COMPONENT_REF, field_type, base, f, NULL_TREE);
+      SET_EXPR_LOCATION (new_base, loc);
+
+      /* Recurse to possibly find the match.  */
+      ret = maybe_fold_offset_to_array_ref (loc, new_base, t, orig_type,
+                                           f == TYPE_FIELDS (record_type));
+      if (ret)
+       return ret;
+      ret = maybe_fold_offset_to_component_ref (loc, field_type, new_base, t,
+                                               orig_type);
+      if (ret)
+       return ret;
+    }
+
+  if (!tail_array_field)
+    return NULL_TREE;
+
+  f = tail_array_field;
+  field_type = TREE_TYPE (f);
+  offset = int_const_binop (MINUS_EXPR, offset, byte_position (f), 1);
+
+  /* If we get here, we've got an aggregate field, and a possibly
+     nonzero offset into them.  Recurse and hope for a valid match.  */
+  base = build3 (COMPONENT_REF, field_type, base, f, NULL_TREE);
+  SET_EXPR_LOCATION (base, loc);
+
+  t = maybe_fold_offset_to_array_ref (loc, base, offset, orig_type,
+                                     f == TYPE_FIELDS (record_type));
+  if (t)
+    return t;
+  return maybe_fold_offset_to_component_ref (loc, field_type, base, offset,
+                                            orig_type);
+}
+
+/* Attempt to express (ORIG_TYPE)BASE+OFFSET as BASE->field_of_orig_type
+   or BASE[index] or by combination of those.
+
+   LOC is the location of original expression.
+
+   Before attempting the conversion strip off existing ADDR_EXPRs and
+   handled component refs.  */
+
+tree
+maybe_fold_offset_to_reference (location_t loc, tree base, tree offset,
+                               tree orig_type)
+{
+  tree ret;
+  tree type;
+
+  STRIP_NOPS (base);
+  if (TREE_CODE (base) != ADDR_EXPR)
+    return NULL_TREE;
+
+  base = TREE_OPERAND (base, 0);
+
+  /* Handle case where existing COMPONENT_REF pick e.g. wrong field of union,
+     so it needs to be removed and new COMPONENT_REF constructed.
+     The wrong COMPONENT_REF are often constructed by folding the
+     (type *)&object within the expression (type *)&object+offset  */
+  if (handled_component_p (base))
+    {
+      HOST_WIDE_INT sub_offset, size, maxsize;
+      tree newbase;
+      newbase = get_ref_base_and_extent (base, &sub_offset,
+                                        &size, &maxsize);
+      gcc_assert (newbase);
+      if (size == maxsize
+         && size != -1
+         && !(sub_offset & (BITS_PER_UNIT - 1)))
+       {
+         base = newbase;
+         if (sub_offset)
+           offset = int_const_binop (PLUS_EXPR, offset,
+                                     build_int_cst (TREE_TYPE (offset),
+                                                    sub_offset / BITS_PER_UNIT), 1);
+       }
+    }
+  if (useless_type_conversion_p (orig_type, TREE_TYPE (base))
+      && integer_zerop (offset))
+    return base;
+  type = TREE_TYPE (base);
+
+  ret = maybe_fold_offset_to_component_ref (loc, type, base, offset, orig_type);
+  if (!ret)
+    ret = maybe_fold_offset_to_array_ref (loc, base, offset, orig_type, true);
+
+  return ret;
+}
+
+/* Attempt to express (ORIG_TYPE)&BASE+OFFSET as &BASE->field_of_orig_type
+   or &BASE[index] or by combination of those.
+
+   LOC is the location of the original expression.
+
+   Before attempting the conversion strip off existing component refs.  */
+
+tree
+maybe_fold_offset_to_address (location_t loc, tree addr, tree offset,
+                             tree orig_type)
+{
+  tree t;
+
+  gcc_assert (POINTER_TYPE_P (TREE_TYPE (addr))
+             && POINTER_TYPE_P (orig_type));
+
+  t = maybe_fold_offset_to_reference (loc, addr, offset,
+                                     TREE_TYPE (orig_type));
+  if (t != NULL_TREE)
+    {
+      tree orig = addr;
+      tree ptr_type;
+
+      /* For __builtin_object_size to function correctly we need to
+         make sure not to fold address arithmetic so that we change
+        reference from one array to another.  This would happen for
+        example for
+
+          struct X { char s1[10]; char s2[10] } s;
+          char *foo (void) { return &s.s2[-4]; }
+
+        where we need to avoid generating &s.s1[6].  As the C and
+        C++ frontends create different initial trees
+        (char *) &s.s1 + -4  vs.  &s.s1[-4]  we have to do some
+        sophisticated comparisons here.  Note that checking for the
+        condition after the fact is easier than trying to avoid doing
+        the folding.  */
+      STRIP_NOPS (orig);
+      if (TREE_CODE (orig) == ADDR_EXPR)
+       orig = TREE_OPERAND (orig, 0);
+      if ((TREE_CODE (orig) == ARRAY_REF
+          || (TREE_CODE (orig) == COMPONENT_REF
+              && TREE_CODE (TREE_TYPE (TREE_OPERAND (orig, 1))) == ARRAY_TYPE))
+         && (TREE_CODE (t) == ARRAY_REF
+             || TREE_CODE (t) == COMPONENT_REF)
+         && !operand_equal_p (TREE_CODE (orig) == ARRAY_REF
+                              ? TREE_OPERAND (orig, 0) : orig,
+                              TREE_CODE (t) == ARRAY_REF
+                              ? TREE_OPERAND (t, 0) : t, 0))
+       return NULL_TREE;
+
+      ptr_type = build_pointer_type (TREE_TYPE (t));
+      if (!useless_type_conversion_p (orig_type, ptr_type))
+       return NULL_TREE;
+      return build_fold_addr_expr_with_type_loc (loc, t, ptr_type);
+    }
+
+  return NULL_TREE;
+}
+
+/* A subroutine of fold_stmt.  Attempt to simplify *(BASE+OFFSET).
+   Return the simplified expression, or NULL if nothing could be done.  */
+
+static tree
+maybe_fold_stmt_indirect (tree expr, tree base, tree offset)
+{
+  tree t;
+  bool volatile_p = TREE_THIS_VOLATILE (expr);
+  location_t loc = EXPR_LOCATION (expr);
+
+  /* We may well have constructed a double-nested PLUS_EXPR via multiple
+     substitutions.  Fold that down to one.  Remove NON_LVALUE_EXPRs that
+     are sometimes added.  */
+  base = fold (base);
+  STRIP_TYPE_NOPS (base);
+  TREE_OPERAND (expr, 0) = base;
+
+  /* One possibility is that the address reduces to a string constant.  */
+  t = fold_read_from_constant_string (expr);
+  if (t)
+    return t;
+
+  /* Add in any offset from a POINTER_PLUS_EXPR.  */
+  if (TREE_CODE (base) == POINTER_PLUS_EXPR)
+    {
+      tree offset2;
+
+      offset2 = TREE_OPERAND (base, 1);
+      if (TREE_CODE (offset2) != INTEGER_CST)
+       return NULL_TREE;
+      base = TREE_OPERAND (base, 0);
+
+      offset = fold_convert (sizetype,
+                            int_const_binop (PLUS_EXPR, offset, offset2, 1));
+    }
+
+  if (TREE_CODE (base) == ADDR_EXPR)
+    {
+      tree base_addr = base;
+
+      /* Strip the ADDR_EXPR.  */
+      base = TREE_OPERAND (base, 0);
+
+      /* Fold away CONST_DECL to its value, if the type is scalar.  */
+      if (TREE_CODE (base) == CONST_DECL
+         && is_gimple_min_invariant (DECL_INITIAL (base)))
+       return DECL_INITIAL (base);
+
+      /* If there is no offset involved simply return the folded base.  */
+      if (integer_zerop (offset))
+       return base;
+
+      /* Try folding *(&B+O) to B.X.  */
+      t = maybe_fold_offset_to_reference (loc, base_addr, offset,
+                                         TREE_TYPE (expr));
+      if (t)
+       {
+         /* Preserve volatileness of the original expression.
+            We can end up with a plain decl here which is shared
+            and we shouldn't mess with its flags.  */
+         if (!SSA_VAR_P (t))
+           TREE_THIS_VOLATILE (t) = volatile_p;
+         return t;
+       }
+    }
+  else
+    {
+      /* We can get here for out-of-range string constant accesses,
+        such as "_"[3].  Bail out of the entire substitution search
+        and arrange for the entire statement to be replaced by a
+        call to __builtin_trap.  In all likelihood this will all be
+        constant-folded away, but in the meantime we can't leave with
+        something that get_expr_operands can't understand.  */
+
+      t = base;
+      STRIP_NOPS (t);
+      if (TREE_CODE (t) == ADDR_EXPR
+         && TREE_CODE (TREE_OPERAND (t, 0)) == STRING_CST)
+       {
+         /* FIXME: Except that this causes problems elsewhere with dead
+            code not being deleted, and we die in the rtl expanders
+            because we failed to remove some ssa_name.  In the meantime,
+            just return zero.  */
+         /* FIXME2: This condition should be signaled by
+            fold_read_from_constant_string directly, rather than
+            re-checking for it here.  */
+         return integer_zero_node;
+       }
+
+      /* Try folding *(B+O) to B->X.  Still an improvement.  */
+      if (POINTER_TYPE_P (TREE_TYPE (base)))
+       {
+          t = maybe_fold_offset_to_reference (loc, base, offset,
+                                             TREE_TYPE (expr));
+         if (t)
+           return t;
+       }
+    }
+
+  /* Otherwise we had an offset that we could not simplify.  */
+  return NULL_TREE;
+}
+
+
+/* A quaint feature extant in our address arithmetic is that there
+   can be hidden type changes here.  The type of the result need
+   not be the same as the type of the input pointer.
+
+   What we're after here is an expression of the form
+       (T *)(&array + const)
+   where array is OP0, const is OP1, RES_TYPE is T and
+   the cast doesn't actually exist, but is implicit in the
+   type of the POINTER_PLUS_EXPR.  We'd like to turn this into
+       &array[x]
+   which may be able to propagate further.  */
+
+tree
+maybe_fold_stmt_addition (location_t loc, tree res_type, tree op0, tree op1)
+{
+  tree ptd_type;
+  tree t;
+
+  /* The first operand should be an ADDR_EXPR.  */
+  if (TREE_CODE (op0) != ADDR_EXPR)
+    return NULL_TREE;
+  op0 = TREE_OPERAND (op0, 0);
+
+  /* It had better be a constant.  */
+  if (TREE_CODE (op1) != INTEGER_CST)
+    {
+      /* Or op0 should now be A[0] and the non-constant offset defined
+        via a multiplication by the array element size.  */
+      if (TREE_CODE (op0) == ARRAY_REF
+         && integer_zerop (TREE_OPERAND (op0, 1))
+         && TREE_CODE (op1) == SSA_NAME
+         && host_integerp (TYPE_SIZE_UNIT (TREE_TYPE (op0)), 1))
+       {
+         gimple offset_def = SSA_NAME_DEF_STMT (op1);
+         if (!is_gimple_assign (offset_def))
+           return NULL_TREE;
+
+         if (gimple_assign_rhs_code (offset_def) == MULT_EXPR
+             && TREE_CODE (gimple_assign_rhs2 (offset_def)) == INTEGER_CST
+             && tree_int_cst_equal (gimple_assign_rhs2 (offset_def),
+                                    TYPE_SIZE_UNIT (TREE_TYPE (op0))))
+           return build_fold_addr_expr
+                         (build4 (ARRAY_REF, TREE_TYPE (op0),
+                                  TREE_OPERAND (op0, 0),
+                                  gimple_assign_rhs1 (offset_def),
+                                  TREE_OPERAND (op0, 2),
+                                  TREE_OPERAND (op0, 3)));
+         else if (integer_onep (TYPE_SIZE_UNIT (TREE_TYPE (op0)))
+                  && gimple_assign_rhs_code (offset_def) != MULT_EXPR)
+           return build_fold_addr_expr
+                         (build4 (ARRAY_REF, TREE_TYPE (op0),
+                                  TREE_OPERAND (op0, 0),
+                                  op1,
+                                  TREE_OPERAND (op0, 2),
+                                  TREE_OPERAND (op0, 3)));
+       }
+      return NULL_TREE;
+    }
+
+  /* If the first operand is an ARRAY_REF, expand it so that we can fold
+     the offset into it.  */
+  while (TREE_CODE (op0) == ARRAY_REF)
+    {
+      tree array_obj = TREE_OPERAND (op0, 0);
+      tree array_idx = TREE_OPERAND (op0, 1);
+      tree elt_type = TREE_TYPE (op0);
+      tree elt_size = TYPE_SIZE_UNIT (elt_type);
+      tree min_idx;
+
+      if (TREE_CODE (array_idx) != INTEGER_CST)
+       break;
+      if (TREE_CODE (elt_size) != INTEGER_CST)
+       break;
+
+      /* Un-bias the index by the min index of the array type.  */
+      min_idx = TYPE_DOMAIN (TREE_TYPE (array_obj));
+      if (min_idx)
+       {
+         min_idx = TYPE_MIN_VALUE (min_idx);
+         if (min_idx)
+           {
+             if (TREE_CODE (min_idx) != INTEGER_CST)
+               break;
+
+             array_idx = fold_convert (TREE_TYPE (min_idx), array_idx);
+             if (!integer_zerop (min_idx))
+               array_idx = int_const_binop (MINUS_EXPR, array_idx,
+                                            min_idx, 0);
+           }
+       }
+
+      /* Convert the index to a byte offset.  */
+      array_idx = fold_convert (sizetype, array_idx);
+      array_idx = int_const_binop (MULT_EXPR, array_idx, elt_size, 0);
+
+      /* Update the operands for the next round, or for folding.  */
+      op1 = int_const_binop (PLUS_EXPR,
+                            array_idx, op1, 0);
+      op0 = array_obj;
+    }
+
+  ptd_type = TREE_TYPE (res_type);
+  /* If we want a pointer to void, reconstruct the reference from the
+     array element type.  A pointer to that can be trivially converted
+     to void *.  This happens as we fold (void *)(ptr p+ off).  */
+  if (VOID_TYPE_P (ptd_type)
+      && TREE_CODE (TREE_TYPE (op0)) == ARRAY_TYPE)
+    ptd_type = TREE_TYPE (TREE_TYPE (op0));
+
+  /* At which point we can try some of the same things as for indirects.  */
+  t = maybe_fold_offset_to_array_ref (loc, op0, op1, ptd_type, true);
+  if (!t)
+    t = maybe_fold_offset_to_component_ref (loc, TREE_TYPE (op0), op0, op1,
+                                           ptd_type);
+  if (t)
+    {
+      t = build1 (ADDR_EXPR, res_type, t);
+      SET_EXPR_LOCATION (t, loc);
+    }
+
+  return t;
+}
+
+/* Subroutine of fold_stmt.  We perform several simplifications of the
+   memory reference tree EXPR and make sure to re-gimplify them properly
+   after propagation of constant addresses.  IS_LHS is true if the
+   reference is supposed to be an lvalue.  */
+
+static tree
+maybe_fold_reference (tree expr, bool is_lhs)
+{
+  tree *t = &expr;
+
+  if (TREE_CODE (expr) == ARRAY_REF
+      && !is_lhs)
+    {
+      tree tem = fold_read_from_constant_string (expr);
+      if (tem)
+       return tem;
+    }
+
+  /* ???  We might want to open-code the relevant remaining cases
+     to avoid using the generic fold.  */
+  if (handled_component_p (*t)
+      && CONSTANT_CLASS_P (TREE_OPERAND (*t, 0)))
+    {
+      tree tem = fold (*t);
+      if (tem != *t)
+       return tem;
+    }
+
+  while (handled_component_p (*t))
+    t = &TREE_OPERAND (*t, 0);
+
+  if (TREE_CODE (*t) == INDIRECT_REF)
+    {
+      tree tem = maybe_fold_stmt_indirect (*t, TREE_OPERAND (*t, 0),
+                                          integer_zero_node);
+      /* Avoid folding *"abc" = 5 into 'a' = 5.  */
+      if (is_lhs && tem && CONSTANT_CLASS_P (tem))
+       tem = NULL_TREE;
+      if (!tem
+         && TREE_CODE (TREE_OPERAND (*t, 0)) == ADDR_EXPR)
+       /* If we had a good reason for propagating the address here,
+          make sure we end up with valid gimple.  See PR34989.  */
+       tem = TREE_OPERAND (TREE_OPERAND (*t, 0), 0);
+
+      if (tem)
+       {
+         *t = tem;
+         tem = maybe_fold_reference (expr, is_lhs);
+         if (tem)
+           return tem;
+         return expr;
+       }
+    }
+  else if (!is_lhs
+          && DECL_P (*t))
+    {
+      tree tem = get_symbol_constant_value (*t);
+      if (tem
+         && useless_type_conversion_p (TREE_TYPE (*t), TREE_TYPE (tem)))
+       {
+         *t = unshare_expr (tem);
+         tem = maybe_fold_reference (expr, is_lhs);
+         if (tem)
+           return tem;
+         return expr;
+       }
+    }
+
+  return NULL_TREE;
+}
+
+
+/* Return the string length, maximum string length or maximum value of
+   ARG in LENGTH.
+   If ARG is an SSA name variable, follow its use-def chains.  If LENGTH
+   is not NULL and, for TYPE == 0, its value is not equal to the length
+   we determine or if we are unable to determine the length or value,
+   return false.  VISITED is a bitmap of visited variables.
+   TYPE is 0 if string length should be returned, 1 for maximum string
+   length and 2 for maximum value ARG can have.  */
+
+static bool
+get_maxval_strlen (tree arg, tree *length, bitmap visited, int type)
+{
+  tree var, val;
+  gimple def_stmt;
+
+  if (TREE_CODE (arg) != SSA_NAME)
+    {
+      if (TREE_CODE (arg) == COND_EXPR)
+        return get_maxval_strlen (COND_EXPR_THEN (arg), length, visited, type)
+               && get_maxval_strlen (COND_EXPR_ELSE (arg), length, visited, type);
+      /* We can end up with &(*iftmp_1)[0] here as well, so handle it.  */
+      else if (TREE_CODE (arg) == ADDR_EXPR
+              && TREE_CODE (TREE_OPERAND (arg, 0)) == ARRAY_REF
+              && integer_zerop (TREE_OPERAND (TREE_OPERAND (arg, 0), 1)))
+       {
+         tree aop0 = TREE_OPERAND (TREE_OPERAND (arg, 0), 0);
+         if (TREE_CODE (aop0) == INDIRECT_REF
+             && TREE_CODE (TREE_OPERAND (aop0, 0)) == SSA_NAME)
+           return get_maxval_strlen (TREE_OPERAND (aop0, 0),
+                                     length, visited, type);
+       }
+
+      if (type == 2)
+       {
+         val = arg;
+         if (TREE_CODE (val) != INTEGER_CST
+             || tree_int_cst_sgn (val) < 0)
+           return false;
+       }
+      else
+       val = c_strlen (arg, 1);
+      if (!val)
+       return false;
+
+      if (*length)
+       {
+         if (type > 0)
+           {
+             if (TREE_CODE (*length) != INTEGER_CST
+                 || TREE_CODE (val) != INTEGER_CST)
+               return false;
+
+             if (tree_int_cst_lt (*length, val))
+               *length = val;
+             return true;
+           }
+         else if (simple_cst_equal (val, *length) != 1)
+           return false;
+       }
+
+      *length = val;
+      return true;
+    }
+
+  /* If we were already here, break the infinite cycle.  */
+  if (bitmap_bit_p (visited, SSA_NAME_VERSION (arg)))
+    return true;
+  bitmap_set_bit (visited, SSA_NAME_VERSION (arg));
+
+  var = arg;
+  def_stmt = SSA_NAME_DEF_STMT (var);
+
+  switch (gimple_code (def_stmt))
+    {
+      case GIMPLE_ASSIGN:
+        /* The RHS of the statement defining VAR must either have a
+           constant length or come from another SSA_NAME with a constant
+           length.  */
+        if (gimple_assign_single_p (def_stmt)
+            || gimple_assign_unary_nop_p (def_stmt))
+          {
+            tree rhs = gimple_assign_rhs1 (def_stmt);
+            return get_maxval_strlen (rhs, length, visited, type);
+          }
+        return false;
+
+      case GIMPLE_PHI:
+       {
+         /* All the arguments of the PHI node must have the same constant
+            length.  */
+         unsigned i;
+
+         for (i = 0; i < gimple_phi_num_args (def_stmt); i++)
+          {
+            tree arg = gimple_phi_arg (def_stmt, i)->def;
+
+            /* If this PHI has itself as an argument, we cannot
+               determine the string length of this argument.  However,
+               if we can find a constant string length for the other
+               PHI args then we can still be sure that this is a
+               constant string length.  So be optimistic and just
+               continue with the next argument.  */
+            if (arg == gimple_phi_result (def_stmt))
+              continue;
+
+            if (!get_maxval_strlen (arg, length, visited, type))
+              return false;
+          }
+        }
+        return true;
+
+      default:
+        return false;
+    }
+}
+
+
+/* Fold builtin call in statement STMT.  Returns a simplified tree.
+   We may return a non-constant expression, including another call
+   to a different function and with different arguments, e.g.,
+   substituting memcpy for strcpy when the string length is known.
+   Note that some builtins expand into inline code that may not
+   be valid in GIMPLE.  Callers must take care.  */
+
+static tree
+ccp_fold_builtin (gimple stmt)
+{
+  tree result, val[3];
+  tree callee, a;
+  int arg_idx, type;
+  bitmap visited;
+  bool ignore;
+  int nargs;
+  location_t loc = gimple_location (stmt);
+
+  gcc_assert (is_gimple_call (stmt));
+
+  ignore = (gimple_call_lhs (stmt) == NULL);
+
+  /* First try the generic builtin folder.  If that succeeds, return the
+     result directly.  */
+  result = fold_call_stmt (stmt, ignore);
+  if (result)
+    {
+      if (ignore)
+       STRIP_NOPS (result);
+      return result;
+    }
+
+  /* Ignore MD builtins.  */
+  callee = gimple_call_fndecl (stmt);
+  if (DECL_BUILT_IN_CLASS (callee) == BUILT_IN_MD)
+    return NULL_TREE;
+
+  /* If the builtin could not be folded, and it has no argument list,
+     we're done.  */
+  nargs = gimple_call_num_args (stmt);
+  if (nargs == 0)
+    return NULL_TREE;
+
+  /* Limit the work only for builtins we know how to simplify.  */
+  switch (DECL_FUNCTION_CODE (callee))
+    {
+    case BUILT_IN_STRLEN:
+    case BUILT_IN_FPUTS:
+    case BUILT_IN_FPUTS_UNLOCKED:
+      arg_idx = 0;
+      type = 0;
+      break;
+    case BUILT_IN_STRCPY:
+    case BUILT_IN_STRNCPY:
+      arg_idx = 1;
+      type = 0;
+      break;
+    case BUILT_IN_MEMCPY_CHK:
+    case BUILT_IN_MEMPCPY_CHK:
+    case BUILT_IN_MEMMOVE_CHK:
+    case BUILT_IN_MEMSET_CHK:
+    case BUILT_IN_STRNCPY_CHK:
+      arg_idx = 2;
+      type = 2;
+      break;
+    case BUILT_IN_STRCPY_CHK:
+    case BUILT_IN_STPCPY_CHK:
+      arg_idx = 1;
+      type = 1;
+      break;
+    case BUILT_IN_SNPRINTF_CHK:
+    case BUILT_IN_VSNPRINTF_CHK:
+      arg_idx = 1;
+      type = 2;
+      break;
+    default:
+      return NULL_TREE;
+    }
+
+  if (arg_idx >= nargs)
+    return NULL_TREE;
+
+  /* Try to use the dataflow information gathered by the CCP process.  */
+  visited = BITMAP_ALLOC (NULL);
+  bitmap_clear (visited);
+
+  memset (val, 0, sizeof (val));
+  a = gimple_call_arg (stmt, arg_idx);
+  if (!get_maxval_strlen (a, &val[arg_idx], visited, type))
+    val[arg_idx] = NULL_TREE;
+
+  BITMAP_FREE (visited);
+
+  result = NULL_TREE;
+  switch (DECL_FUNCTION_CODE (callee))
+    {
+    case BUILT_IN_STRLEN:
+      if (val[0] && nargs == 1)
+       {
+         tree new_val =
+              fold_convert (TREE_TYPE (gimple_call_lhs (stmt)), val[0]);
+
+         /* If the result is not a valid gimple value, or not a cast
+            of a valid gimple value, then we can not use the result.  */
+         if (is_gimple_val (new_val)
+             || (is_gimple_cast (new_val)
+                 && is_gimple_val (TREE_OPERAND (new_val, 0))))
+           return new_val;
+       }
+      break;
+
+    case BUILT_IN_STRCPY:
+      if (val[1] && is_gimple_val (val[1]) && nargs == 2)
+       result = fold_builtin_strcpy (loc, callee,
+                                      gimple_call_arg (stmt, 0),
+                                      gimple_call_arg (stmt, 1),
+                                     val[1]);
+      break;
+
+    case BUILT_IN_STRNCPY:
+      if (val[1] && is_gimple_val (val[1]) && nargs == 3)
+       result = fold_builtin_strncpy (loc, callee,
+                                       gimple_call_arg (stmt, 0),
+                                       gimple_call_arg (stmt, 1),
+                                       gimple_call_arg (stmt, 2),
+                                      val[1]);
+      break;
+
+    case BUILT_IN_FPUTS:
+      if (nargs == 2)
+       result = fold_builtin_fputs (loc, gimple_call_arg (stmt, 0),
+                                    gimple_call_arg (stmt, 1),
+                                    ignore, false, val[0]);
+      break;
+
+    case BUILT_IN_FPUTS_UNLOCKED:
+      if (nargs == 2)
+       result = fold_builtin_fputs (loc, gimple_call_arg (stmt, 0),
+                                    gimple_call_arg (stmt, 1),
+                                    ignore, true, val[0]);
+      break;
+
+    case BUILT_IN_MEMCPY_CHK:
+    case BUILT_IN_MEMPCPY_CHK:
+    case BUILT_IN_MEMMOVE_CHK:
+    case BUILT_IN_MEMSET_CHK:
+      if (val[2] && is_gimple_val (val[2]) && nargs == 4)
+       result = fold_builtin_memory_chk (loc, callee,
+                                          gimple_call_arg (stmt, 0),
+                                          gimple_call_arg (stmt, 1),
+                                          gimple_call_arg (stmt, 2),
+                                          gimple_call_arg (stmt, 3),
+                                         val[2], ignore,
+                                         DECL_FUNCTION_CODE (callee));
+      break;
+
+    case BUILT_IN_STRCPY_CHK:
+    case BUILT_IN_STPCPY_CHK:
+      if (val[1] && is_gimple_val (val[1]) && nargs == 3)
+       result = fold_builtin_stxcpy_chk (loc, callee,
+                                          gimple_call_arg (stmt, 0),
+                                          gimple_call_arg (stmt, 1),
+                                          gimple_call_arg (stmt, 2),
+                                         val[1], ignore,
+                                         DECL_FUNCTION_CODE (callee));
+      break;
+
+    case BUILT_IN_STRNCPY_CHK:
+      if (val[2] && is_gimple_val (val[2]) && nargs == 4)
+       result = fold_builtin_strncpy_chk (loc, gimple_call_arg (stmt, 0),
+                                           gimple_call_arg (stmt, 1),
+                                           gimple_call_arg (stmt, 2),
+                                           gimple_call_arg (stmt, 3),
+                                          val[2]);
+      break;
+
+    case BUILT_IN_SNPRINTF_CHK:
+    case BUILT_IN_VSNPRINTF_CHK:
+      if (val[1] && is_gimple_val (val[1]))
+       result = gimple_fold_builtin_snprintf_chk (stmt, val[1],
+                                                   DECL_FUNCTION_CODE (callee));
+      break;
+
+    default:
+      gcc_unreachable ();
+    }
+
+  if (result && ignore)
+    result = fold_ignored_result (result);
+  return result;
+}
+
+/* Attempt to fold an assignment statement pointed-to by SI.  Returns a
+   replacement rhs for the statement or NULL_TREE if no simplification
+   could be made.  It is assumed that the operands have been previously
+   folded.  */
+
+static tree
+fold_gimple_assign (gimple_stmt_iterator *si)
+{
+  gimple stmt = gsi_stmt (*si);
+  enum tree_code subcode = gimple_assign_rhs_code (stmt);
+  location_t loc = gimple_location (stmt);
+
+  tree result = NULL_TREE;
+
+  switch (get_gimple_rhs_class (subcode))
+    {
+    case GIMPLE_SINGLE_RHS:
+      {
+        tree rhs = gimple_assign_rhs1 (stmt);
+
+        /* Try to fold a conditional expression.  */
+        if (TREE_CODE (rhs) == COND_EXPR)
+          {
+           tree op0 = COND_EXPR_COND (rhs);
+           tree tem;
+           bool set = false;
+           location_t cond_loc = EXPR_LOCATION (rhs);
+
+           if (COMPARISON_CLASS_P (op0))
+             {
+               fold_defer_overflow_warnings ();
+               tem = fold_binary_loc (cond_loc,
+                                  TREE_CODE (op0), TREE_TYPE (op0),
+                                  TREE_OPERAND (op0, 0),
+                                  TREE_OPERAND (op0, 1));
+               /* This is actually a conditional expression, not a GIMPLE
+                  conditional statement, however, the valid_gimple_rhs_p
+                  test still applies.  */
+               set = (tem && is_gimple_condexpr (tem)
+                      && valid_gimple_rhs_p (tem));
+               fold_undefer_overflow_warnings (set, stmt, 0);
+             }
+           else if (is_gimple_min_invariant (op0))
+             {
+               tem = op0;
+               set = true;
+             }
+           else
+             return NULL_TREE;
+
+           if (set)
+             result = fold_build3_loc (cond_loc, COND_EXPR, TREE_TYPE (rhs), tem,
+                                   COND_EXPR_THEN (rhs), COND_EXPR_ELSE (rhs));
+          }
+
+       else if (TREE_CODE (rhs) == TARGET_MEM_REF)
+         return maybe_fold_tmr (rhs);
+
+       else if (REFERENCE_CLASS_P (rhs))
+         return maybe_fold_reference (rhs, false);
+
+       else if (TREE_CODE (rhs) == ADDR_EXPR)
+         {
+           tree tem = maybe_fold_reference (TREE_OPERAND (rhs, 0), true);
+           if (tem)
+             result = fold_convert (TREE_TYPE (rhs),
+                                    build_fold_addr_expr_loc (loc, tem));
+         }
+
+       else if (TREE_CODE (rhs) == CONSTRUCTOR
+                && TREE_CODE (TREE_TYPE (rhs)) == VECTOR_TYPE
+                && (CONSTRUCTOR_NELTS (rhs)
+                    == TYPE_VECTOR_SUBPARTS (TREE_TYPE (rhs))))
+         {
+           /* Fold a constant vector CONSTRUCTOR to VECTOR_CST.  */
+           unsigned i;
+           tree val;
+
+           FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (rhs), i, val)
+             if (TREE_CODE (val) != INTEGER_CST
+                 && TREE_CODE (val) != REAL_CST
+                 && TREE_CODE (val) != FIXED_CST)
+               return NULL_TREE;
+
+           return build_vector_from_ctor (TREE_TYPE (rhs),
+                                          CONSTRUCTOR_ELTS (rhs));
+         }
+
+       else if (DECL_P (rhs))
+         return unshare_expr (get_symbol_constant_value (rhs));
+
+        /* If we couldn't fold the RHS, hand over to the generic
+           fold routines.  */
+        if (result == NULL_TREE)
+          result = fold (rhs);
+
+        /* Strip away useless type conversions.  Both the NON_LVALUE_EXPR
+           that may have been added by fold, and "useless" type
+           conversions that might now be apparent due to propagation.  */
+        STRIP_USELESS_TYPE_CONVERSION (result);
+
+        if (result != rhs && valid_gimple_rhs_p (result))
+         return result;
+
+       return NULL_TREE;
+      }
+      break;
+
+    case GIMPLE_UNARY_RHS:
+      {
+       tree rhs = gimple_assign_rhs1 (stmt);
+
+       result = fold_unary_loc (loc, subcode, gimple_expr_type (stmt), rhs);
+       if (result)
+         {
+           /* If the operation was a conversion do _not_ mark a
+              resulting constant with TREE_OVERFLOW if the original
+              constant was not.  These conversions have implementation
+              defined behavior and retaining the TREE_OVERFLOW flag
+              here would confuse later passes such as VRP.  */
+           if (CONVERT_EXPR_CODE_P (subcode)
+               && TREE_CODE (result) == INTEGER_CST
+               && TREE_CODE (rhs) == INTEGER_CST)
+             TREE_OVERFLOW (result) = TREE_OVERFLOW (rhs);
+
+           STRIP_USELESS_TYPE_CONVERSION (result);
+           if (valid_gimple_rhs_p (result))
+             return result;
+         }
+       else if (CONVERT_EXPR_CODE_P (subcode)
+                && POINTER_TYPE_P (gimple_expr_type (stmt))
+                && POINTER_TYPE_P (TREE_TYPE (gimple_assign_rhs1 (stmt))))
+         {
+           tree type = gimple_expr_type (stmt);
+           tree t = maybe_fold_offset_to_address (loc,
+                                                  gimple_assign_rhs1 (stmt),
+                                                  integer_zero_node, type);
+           if (t)
+             return t;
+         }
+      }
+      break;
+
+    case GIMPLE_BINARY_RHS:
+      /* Try to fold pointer addition.  */
+      if (gimple_assign_rhs_code (stmt) == POINTER_PLUS_EXPR)
+       {
+         tree type = TREE_TYPE (gimple_assign_rhs1 (stmt));
+         if (TREE_CODE (TREE_TYPE (type)) == ARRAY_TYPE)
+           {
+             type = build_pointer_type (TREE_TYPE (TREE_TYPE (type)));
+             if (!useless_type_conversion_p
+                   (TREE_TYPE (gimple_assign_lhs (stmt)), type))
+               type = TREE_TYPE (gimple_assign_rhs1 (stmt));
+           }
+         result = maybe_fold_stmt_addition (gimple_location (stmt),
+                                            type,
+                                            gimple_assign_rhs1 (stmt),
+                                            gimple_assign_rhs2 (stmt));
+       }
+
+      if (!result)
+        result = fold_binary_loc (loc, subcode,
+                              TREE_TYPE (gimple_assign_lhs (stmt)),
+                              gimple_assign_rhs1 (stmt),
+                              gimple_assign_rhs2 (stmt));
+
+      if (result)
+        {
+          STRIP_USELESS_TYPE_CONVERSION (result);
+          if (valid_gimple_rhs_p (result))
+           return result;
+
+         /* Fold might have produced non-GIMPLE, so if we trust it blindly
+            we lose canonicalization opportunities.  Do not go again
+            through fold here though, or the same non-GIMPLE will be
+            produced.  */
+          if (commutative_tree_code (subcode)
+              && tree_swap_operands_p (gimple_assign_rhs1 (stmt),
+                                       gimple_assign_rhs2 (stmt), false))
+            return build2 (subcode, TREE_TYPE (gimple_assign_lhs (stmt)),
+                           gimple_assign_rhs2 (stmt),
+                           gimple_assign_rhs1 (stmt));
+        }
+      break;
+
+    case GIMPLE_INVALID_RHS:
+      gcc_unreachable ();
+    }
+
+  return NULL_TREE;
+}
+
+/* Attempt to fold a conditional statement. Return true if any changes were
+   made. We only attempt to fold the condition expression, and do not perform
+   any transformation that would require alteration of the cfg.  It is
+   assumed that the operands have been previously folded.  */
+
+static bool
+fold_gimple_cond (gimple stmt)
+{
+  tree result = fold_binary_loc (gimple_location (stmt),
+                            gimple_cond_code (stmt),
+                             boolean_type_node,
+                             gimple_cond_lhs (stmt),
+                             gimple_cond_rhs (stmt));
+
+  if (result)
+    {
+      STRIP_USELESS_TYPE_CONVERSION (result);
+      if (is_gimple_condexpr (result) && valid_gimple_rhs_p (result))
+        {
+          gimple_cond_set_condition_from_tree (stmt, result);
+          return true;
+        }
+    }
+
+  return false;
+}
+
+static void gimplify_and_update_call_from_tree (gimple_stmt_iterator *, tree);
+
+/* Attempt to fold a call statement referenced by the statement iterator GSI.
+   The statement may be replaced by another statement, e.g., if the call
+   simplifies to a constant value. Return true if any changes were made.
+   It is assumed that the operands have been previously folded.  */
+
+static bool
+fold_gimple_call (gimple_stmt_iterator *gsi)
+{
+  gimple stmt = gsi_stmt (*gsi);
+
+  tree callee = gimple_call_fndecl (stmt);
+
+  /* Check for builtins that CCP can handle using information not
+     available in the generic fold routines.  */
+  if (callee && DECL_BUILT_IN (callee))
+    {
+      tree result = ccp_fold_builtin (stmt);
+
+      if (result)
+       {
+          if (!update_call_from_tree (gsi, result))
+           gimplify_and_update_call_from_tree (gsi, result);
+         return true;
+       }
+    }
+  else
+    {
+      /* Check for resolvable OBJ_TYPE_REF.  The only sorts we can resolve
+         here are when we've propagated the address of a decl into the
+         object slot.  */
+      /* ??? Should perhaps do this in fold proper.  However, doing it
+         there requires that we create a new CALL_EXPR, and that requires
+         copying EH region info to the new node.  Easier to just do it
+         here where we can just smash the call operand.  */
+      /* ??? Is there a good reason not to do this in fold_stmt_inplace?  */
+      callee = gimple_call_fn (stmt);
+      if (TREE_CODE (callee) == OBJ_TYPE_REF
+          && lang_hooks.fold_obj_type_ref
+          && TREE_CODE (OBJ_TYPE_REF_OBJECT (callee)) == ADDR_EXPR
+          && DECL_P (TREE_OPERAND
+                     (OBJ_TYPE_REF_OBJECT (callee), 0)))
+        {
+          tree t;
+
+          /* ??? Caution: Broken ADDR_EXPR semantics means that
+             looking at the type of the operand of the addr_expr
+             can yield an array type.  See silly exception in
+             check_pointer_types_r.  */
+          t = TREE_TYPE (TREE_TYPE (OBJ_TYPE_REF_OBJECT (callee)));
+          t = lang_hooks.fold_obj_type_ref (callee, t);
+          if (t)
+            {
+              gimple_call_set_fn (stmt, t);
+              return true;
+            }
+        }
+    }
+
+  return false;
+}
+
+/* Worker for both fold_stmt and fold_stmt_inplace.  The INPLACE argument
+   distinguishes both cases.  */
+
+static bool
+fold_stmt_1 (gimple_stmt_iterator *gsi, bool inplace)
+{
+  bool changed = false;
+  gimple stmt = gsi_stmt (*gsi);
+  unsigned i;
+
+  /* Fold the main computation performed by the statement.  */
+  switch (gimple_code (stmt))
+    {
+    case GIMPLE_ASSIGN:
+      {
+       unsigned old_num_ops = gimple_num_ops (stmt);
+       tree new_rhs = fold_gimple_assign (gsi);
+       tree lhs = gimple_assign_lhs (stmt);
+       if (new_rhs
+           && !useless_type_conversion_p (TREE_TYPE (lhs),
+                                          TREE_TYPE (new_rhs)))
+         new_rhs = fold_convert (TREE_TYPE (lhs), new_rhs);
+       if (new_rhs
+           && (!inplace
+               || get_gimple_rhs_num_ops (TREE_CODE (new_rhs)) < old_num_ops))
+         {
+           gimple_assign_set_rhs_from_tree (gsi, new_rhs);
+           changed = true;
+         }
+       break;
+      }
+
+    case GIMPLE_COND:
+      changed |= fold_gimple_cond (stmt);
+      break;
+
+    case GIMPLE_CALL:
+      /* Fold *& in call arguments.  */
+      for (i = 0; i < gimple_call_num_args (stmt); ++i)
+       if (REFERENCE_CLASS_P (gimple_call_arg (stmt, i)))
+         {
+           tree tmp = maybe_fold_reference (gimple_call_arg (stmt, i), false);
+           if (tmp)
+             {
+               gimple_call_set_arg (stmt, i, tmp);
+               changed = true;
+             }
+         }
+      /* The entire statement may be replaced in this case.  */
+      if (!inplace)
+       changed |= fold_gimple_call (gsi);
+      break;
+
+    case GIMPLE_ASM:
+      /* Fold *& in asm operands.  */
+      for (i = 0; i < gimple_asm_noutputs (stmt); ++i)
+       {
+         tree link = gimple_asm_output_op (stmt, i);
+         tree op = TREE_VALUE (link);
+         if (REFERENCE_CLASS_P (op)
+             && (op = maybe_fold_reference (op, true)) != NULL_TREE)
+           {
+             TREE_VALUE (link) = op;
+             changed = true;
+           }
+       }
+      for (i = 0; i < gimple_asm_ninputs (stmt); ++i)
+       {
+         tree link = gimple_asm_input_op (stmt, i);
+         tree op = TREE_VALUE (link);
+         if (REFERENCE_CLASS_P (op)
+             && (op = maybe_fold_reference (op, false)) != NULL_TREE)
+           {
+             TREE_VALUE (link) = op;
+             changed = true;
+           }
+       }
+      break;
+
+    default:;
+    }
+
+  stmt = gsi_stmt (*gsi);
+
+  /* Fold *& on the lhs.  */
+  if (gimple_has_lhs (stmt))
+    {
+      tree lhs = gimple_get_lhs (stmt);
+      if (lhs && REFERENCE_CLASS_P (lhs))
+       {
+         tree new_lhs = maybe_fold_reference (lhs, true);
+         if (new_lhs)
+           {
+             gimple_set_lhs (stmt, new_lhs);
+             changed = true;
+           }
+       }
+    }
+
+  return changed;
+}
+
+/* Fold the statement pointed to by GSI.  In some cases, this function may
+   replace the whole statement with a new one.  Returns true iff folding
+   makes any changes.
+   The statement pointed to by GSI should be in valid gimple form but may
+   be in unfolded state as resulting from for example constant propagation
+   which can produce *&x = 0.  */
+
+bool
+fold_stmt (gimple_stmt_iterator *gsi)
+{
+  return fold_stmt_1 (gsi, false);
+}
+
+/* Perform the minimal folding on statement STMT.  Only operations like
+   *&x created by constant propagation are handled.  The statement cannot
+   be replaced with a new one.  Return true if the statement was
+   changed, false otherwise.
+   The statement STMT should be in valid gimple form but may
+   be in unfolded state as resulting from for example constant propagation
+   which can produce *&x = 0.  */
+
+bool
+fold_stmt_inplace (gimple stmt)
+{
+  gimple_stmt_iterator gsi = gsi_for_stmt (stmt);
+  bool changed = fold_stmt_1 (&gsi, true);
+  gcc_assert (gsi_stmt (gsi) == stmt);
+  return changed;
+}
 
 /* Try to optimize out __builtin_stack_restore.  Optimize it out
    if there is another __builtin_stack_restore in the same basic
@@ -1859,6 +3337,80 @@ optimize_stdarg_builtin (gimple call)
     }
 }
 
+/* Convert EXPR into a GIMPLE value suitable for substitution on the
+   RHS of an assignment.  Insert the necessary statements before
+   iterator *SI_P.  The statement at *SI_P, which must be a GIMPLE_CALL
+   is replaced.  If the call is expected to produces a result, then it
+   is replaced by an assignment of the new RHS to the result variable.
+   If the result is to be ignored, then the call is replaced by a
+   GIMPLE_NOP.  */
+
+static void
+gimplify_and_update_call_from_tree (gimple_stmt_iterator *si_p, tree expr)
+{
+  tree lhs;
+  tree tmp = NULL_TREE;  /* Silence warning.  */
+  gimple stmt, new_stmt;
+  gimple_stmt_iterator i;
+  gimple_seq stmts = gimple_seq_alloc();
+  struct gimplify_ctx gctx;
+  gimple last = NULL;
+
+  stmt = gsi_stmt (*si_p);
+
+  gcc_assert (is_gimple_call (stmt));
+
+  lhs = gimple_call_lhs (stmt);
+
+  push_gimplify_context (&gctx);
+
+  if (lhs == NULL_TREE)
+    gimplify_and_add (expr, &stmts);
+  else
+    tmp = get_initialized_tmp_var (expr, &stmts, NULL);
+
+  pop_gimplify_context (NULL);
+
+  if (gimple_has_location (stmt))
+    annotate_all_with_location (stmts, gimple_location (stmt));
+
+  /* The replacement can expose previously unreferenced variables.  */
+  for (i = gsi_start (stmts); !gsi_end_p (i); gsi_next (&i))
+    {
+      if (last)
+       {
+         gsi_insert_before (si_p, last, GSI_NEW_STMT);
+         gsi_next (si_p);
+       }
+      new_stmt = gsi_stmt (i);
+      find_new_referenced_vars (new_stmt);
+      mark_symbols_for_renaming (new_stmt);
+      last = new_stmt;
+    }
+
+  if (lhs == NULL_TREE)
+    {
+      unlink_stmt_vdef (stmt);
+      release_defs (stmt);
+      new_stmt = last;
+    }
+  else
+    {
+      if (last)
+       {
+         gsi_insert_before (si_p, last, GSI_NEW_STMT);
+         gsi_next (si_p);
+       }
+      new_stmt = gimple_build_assign (lhs, tmp);
+      gimple_set_vuse (new_stmt, gimple_vuse (stmt));
+      gimple_set_vdef (new_stmt, gimple_vdef (stmt));
+      move_ssa_defining_stmt_for_defs (new_stmt, stmt);
+    }
+
+  gimple_set_location (new_stmt, gimple_location (stmt));
+  gsi_replace (si_p, new_stmt, false);
+}
+
 /* A simple pass that attempts to fold all builtin functions.  This pass
    is run after we've propagated as many constants as we can.  */
 
@@ -1893,7 +3445,7 @@ execute_fold_all_builtins (void)
            }
          fcode = DECL_FUNCTION_CODE (callee);
 
-         result = gimple_fold_builtin (stmt);
+         result = ccp_fold_builtin (stmt);
 
          if (result)
            gimple_remove_stmt_histograms (cfun, stmt);