defer mark_addressable calls during expand till the end of expand

for  gcc/ChangeLog

	* gimple-expr.c: Include hash-set.h and rtl.h.
	(mark_addressable_queue): New var.
	(mark_addressable): Factor actual marking into...
	(mark_addressable_1): ... this.  Queue it up during expand.
	(mark_addressable_2): New.
	(flush_mark_addressable_queue): New.
	* gimple-expr.h (flush_mark_addressable_queue): Declare.
	* cfgexpand.c: Include gimple-expr.h.
	(pass_expand::execute): Flush mark_addressable queue.

From-SVN: r229696

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index 63297775ec24898b8263302fd5676645aad9a496..16712df8c8a470b8dcdf1cc3748187018340d30d 100644 (file)
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,15 @@
+2015-11-03  Alexandre Oliva <aoliva@redhat.com>
+
+       * gimple-expr.c: Include hash-set.h and rtl.h.
+       (mark_addressable_queue): New var.
+       (mark_addressable): Factor actual marking into...
+       (mark_addressable_1): ... this.  Queue it up during expand.
+       (mark_addressable_2): New.
+       (flush_mark_addressable_queue): New.
+       * gimple-expr.h (flush_mark_addressable_queue): Declare.
+       * cfgexpand.c: Include gimple-expr.h.
+       (pass_expand::execute): Flush mark_addressable queue.
+
 2015-11-02  Alexandre Oliva <aoliva@redhat.com>
 
        * tree-ssa-ifcombine.c (tree_ssa_ifcombine_bb_1): Factor out

diff --git a/gcc/cfgexpand.c b/gcc/cfgexpand.c
index b59ea022fcdd73c39847078bbaf3281f5ef19a77..bfbc958c020e54d15966d7796e38f83e2d81281b 100644 (file)
--- a/gcc/cfgexpand.c
+++ b/gcc/cfgexpand.c
@@ -51,6 +51,7 @@ along with GCC; see the file COPYING3.  If not see
 #include "internal-fn.h"
 #include "tree-eh.h"
 #include "gimple-iterator.h"
+#include "gimple-expr.h"
 #include "gimple-walk.h"
 #include "tree-cfg.h"
 #include "tree-dfa.h"
@@ -6368,6 +6369,8 @@ pass_expand::execute (function *fun)
   /* We're done expanding trees to RTL.  */
   currently_expanding_to_rtl = 0;
 
+  flush_mark_addressable_queue ();
+
   FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR_FOR_FN (fun)->next_bb,
                  EXIT_BLOCK_PTR_FOR_FN (fun), next_bb)
     {

diff --git a/gcc/gimple-expr.c b/gcc/gimple-expr.c
index 44749b816ae0493770bdfe57211d78d11c19d7b0..f5f9e87d56f6b20f860d0e27443ee79553d92e6f 100644 (file)
--- a/gcc/gimple-expr.c
+++ b/gcc/gimple-expr.c
@@ -32,6 +32,8 @@ along with GCC; see the file COPYING3.  If not see
 #include "gimplify.h"
 #include "stor-layout.h"
 #include "demangle.h"
+#include "hash-set.h"
+#include "rtl.h"
 
 /* ----- Type related -----  */
 
@@ -817,6 +819,57 @@ is_gimple_mem_ref_addr (tree t)
                  || decl_address_invariant_p (TREE_OPERAND (t, 0)))));
 }
 
+/* Hold trees marked addressable during expand.  */
+
+static hash_set<tree> *mark_addressable_queue;
+
+/* Mark X as addressable or queue it up if called during expand.  We
+   don't want to apply it immediately during expand because decls are
+   made addressable at that point due to RTL-only concerns, such as
+   uses of memcpy for block moves, and TREE_ADDRESSABLE changes
+   is_gimple_reg, which might make it seem like a variable that used
+   to be a gimple_reg shouldn't have been an SSA name.  So we queue up
+   this flag setting and only apply it when we're done with GIMPLE and
+   only RTL issues matter.  */
+
+static void
+mark_addressable_1 (tree x)
+{
+  if (!currently_expanding_to_rtl)
+    {
+      TREE_ADDRESSABLE (x) = 1;
+      return;
+    }
+
+  if (!mark_addressable_queue)
+    mark_addressable_queue = new hash_set<tree>();
+  mark_addressable_queue->add (x);
+}
+
+/* Adaptor for mark_addressable_1 for use in hash_set traversal.  */
+
+bool
+mark_addressable_2 (tree const &x, void * ATTRIBUTE_UNUSED = NULL)
+{
+  mark_addressable_1 (x);
+  return false;
+}
+
+/* Mark all queued trees as addressable, and empty the queue.  To be
+   called right after clearing CURRENTLY_EXPANDING_TO_RTL.  */
+
+void
+flush_mark_addressable_queue ()
+{
+  gcc_assert (!currently_expanding_to_rtl);
+  if (mark_addressable_queue)
+    {
+      mark_addressable_queue->traverse<void*, mark_addressable_2> (NULL);
+      delete mark_addressable_queue;
+      mark_addressable_queue = NULL;
+    }
+}
+
 /* Mark X addressable.  Unlike the langhook we expect X to be in gimple
    form and we don't do any syntax checking.  */
 
@@ -832,7 +885,7 @@ mark_addressable (tree x)
       && TREE_CODE (x) != PARM_DECL
       && TREE_CODE (x) != RESULT_DECL)
     return;
-  TREE_ADDRESSABLE (x) = 1;
+  mark_addressable_1 (x);
 
   /* Also mark the artificial SSA_NAME that points to the partition of X.  */
   if (TREE_CODE (x) == VAR_DECL
@@ -843,7 +896,7 @@ mark_addressable (tree x)
     {
       tree *namep = cfun->gimple_df->decls_to_pointers->get (x);
       if (namep)
-       TREE_ADDRESSABLE (*namep) = 1;
+       mark_addressable_1 (*namep);
     }
 }
 

diff --git a/gcc/gimple-expr.h b/gcc/gimple-expr.h
index 3d1c89ff371356e88007e315271a541e04455b51..2917d2752cfdaefdabc84ec382ccd2c259523620 100644 (file)
--- a/gcc/gimple-expr.h
+++ b/gcc/gimple-expr.h
@@ -52,6 +52,7 @@ extern bool is_gimple_asm_val (tree);
 extern bool is_gimple_min_lval (tree);
 extern bool is_gimple_call_addr (tree);
 extern bool is_gimple_mem_ref_addr (tree);
+extern void flush_mark_addressable_queue (void);
 extern void mark_addressable (tree);
 extern bool is_gimple_reg_rhs (tree);