Avoid marking TARGET_MEM_REF bases addressable

The following does no longer mark TARGET_MEM_REF bases addressable,
mimicing MEM_REFs beahvior here.  In contrast to the latter,
TARGET_MEM_REF RTL expansion expects to always operate on memory
though, so make sure we expand them so.

2021-05-19  Richard Biener  <rguenther@suse.de>

	* cfgexpand.c (discover_nonconstant_array_refs_r): Make
	sure TARGET_MEM_REF bases are expanded as memory.
	* tree-ssa-operands.c (operands_scanner::get_tmr_operands):
	Do not mark TARGET_MEM_REF bases addressable.
	* tree-ssa.c (non_rewritable_mem_ref_base): Handle
	TARGET_MEM_REF bases as never rewritable.
	* gimple-walk.c (walk_stmt_load_store_addr_ops): Do not
	walk TARGET_MEM_REF bases as address-takens.
	* tree-ssa-dce.c (ref_may_be_aliased): Handle TARGET_MEM_REF.

diff --git a/gcc/cfgexpand.c b/gcc/cfgexpand.c
index 3e6f7ca..39e5b04 100644 (file)
--- a/gcc/cfgexpand.c
+++ b/gcc/cfgexpand.c
@@ -6280,10 +6280,12 @@ discover_nonconstant_array_refs_r (tree * tp, int *walk_subtrees,
     }
   /* References of size POLY_INT_CST to a fixed-size object must go
      through memory.  It's more efficient to force that here than
-     to create temporary slots on the fly.  */
-  else if ((TREE_CODE (t) == MEM_REF || TREE_CODE (t) == TARGET_MEM_REF)
-          && TYPE_SIZE (TREE_TYPE (t))
-          && POLY_INT_CST_P (TYPE_SIZE (TREE_TYPE (t))))
+     to create temporary slots on the fly.
+     RTL expansion expectes TARGET_MEM_REF to always address actual memory.  */
+  else if (TREE_CODE (t) == TARGET_MEM_REF
+          || (TREE_CODE (t) == MEM_REF
+              && TYPE_SIZE (TREE_TYPE (t))
+              && POLY_INT_CST_P (TYPE_SIZE (TREE_TYPE (t)))))
     {
       tree base = get_base_address (t);
       if (base

diff --git a/gcc/gimple-walk.c b/gcc/gimple-walk.c
index f8b0482..e4a55f1 100644 (file)
--- a/gcc/gimple-walk.c
+++ b/gcc/gimple-walk.c
@@ -748,10 +748,6 @@ walk_stmt_load_store_addr_ops (gimple *stmt, void *data,
        {
          if (TREE_CODE (rhs) == ADDR_EXPR)
            ret |= visit_addr (stmt, TREE_OPERAND (rhs, 0), arg, data);
-         else if (TREE_CODE (rhs) == TARGET_MEM_REF
-                  && TREE_CODE (TMR_BASE (rhs)) == ADDR_EXPR)
-           ret |= visit_addr (stmt, TREE_OPERAND (TMR_BASE (rhs), 0), arg,
-                              data);
          else if (TREE_CODE (rhs) == OBJ_TYPE_REF
                   && TREE_CODE (OBJ_TYPE_REF_OBJECT (rhs)) == ADDR_EXPR)
            ret |= visit_addr (stmt, TREE_OPERAND (OBJ_TYPE_REF_OBJECT (rhs),
@@ -770,10 +766,6 @@ walk_stmt_load_store_addr_ops (gimple *stmt, void *data,
                                     TREE_OPERAND (OBJ_TYPE_REF_OBJECT (val),
                                                   0), arg, data);
            }
-          lhs = gimple_assign_lhs (stmt);
-         if (TREE_CODE (lhs) == TARGET_MEM_REF
-              && TREE_CODE (TMR_BASE (lhs)) == ADDR_EXPR)
-           ret |= visit_addr (stmt, TREE_OPERAND (TMR_BASE (lhs), 0), lhs, data);
        }
       if (visit_load)
        {

diff --git a/gcc/tree-ssa-dce.c b/gcc/tree-ssa-dce.c
index c091868..def6ae6 100644 (file)
--- a/gcc/tree-ssa-dce.c
+++ b/gcc/tree-ssa-dce.c
@@ -452,7 +452,7 @@ ref_may_be_aliased (tree ref)
   gcc_assert (TREE_CODE (ref) != WITH_SIZE_EXPR);
   while (handled_component_p (ref))
     ref = TREE_OPERAND (ref, 0);
-  if (TREE_CODE (ref) == MEM_REF
+  if ((TREE_CODE (ref) == MEM_REF || TREE_CODE (ref) == TARGET_MEM_REF)
       && TREE_CODE (TREE_OPERAND (ref, 0)) == ADDR_EXPR)
     ref = TREE_OPERAND (TREE_OPERAND (ref, 0), 0);
   return !(DECL_P (ref)

diff --git a/gcc/tree-ssa-operands.c b/gcc/tree-ssa-operands.c
index 2fc74d5..c155754 100644 (file)
--- a/gcc/tree-ssa-operands.c
+++ b/gcc/tree-ssa-operands.c
@@ -669,7 +669,9 @@ operands_scanner::get_tmr_operands(tree expr, int flags)
     gimple_set_has_volatile_ops (stmt, true);
 
   /* First record the real operands.  */
-  get_expr_operands (&TMR_BASE (expr), opf_use | (flags & opf_no_vops));
+  get_expr_operands (&TMR_BASE (expr),
+                    opf_non_addressable | opf_use
+                    | (flags & (opf_no_vops|opf_not_non_addressable)));
   get_expr_operands (&TMR_INDEX (expr), opf_use | (flags & opf_no_vops));
   get_expr_operands (&TMR_INDEX2 (expr), opf_use | (flags & opf_no_vops));
 

diff --git a/gcc/tree-ssa.c b/gcc/tree-ssa.c
index cf54c89..4cc400d 100644 (file)
--- a/gcc/tree-ssa.c
+++ b/gcc/tree-ssa.c
@@ -1494,6 +1494,16 @@ non_rewritable_mem_ref_base (tree ref)
       return decl;
     }
 
+  /* We cannot rewrite TARGET_MEM_REFs.  */
+  if (TREE_CODE (base) == TARGET_MEM_REF
+      && TREE_CODE (TREE_OPERAND (base, 0)) == ADDR_EXPR)
+    {
+      tree decl = TREE_OPERAND (TREE_OPERAND (base, 0), 0);
+      if (! DECL_P (decl))
+       return NULL_TREE;
+      return decl;
+    }
+
   return NULL_TREE;
 }