Since this optimization now walks the vops, it is better to only
do it in forwprop rather than in all the time in fold_stmt.
The next patch will add the limit to the alias walk.
gcc/ChangeLog:
* gimple-fold.cc (optimize_memcpy_to_memset): Move to
tree-ssa-forwprop.cc.
(gimple_fold_builtin_memory_op): Remove call to
optimize_memcpy_to_memset.
(fold_stmt_1): Likewise.
* tree-ssa-forwprop.cc (optimize_memcpy_to_memset): Move from
gimple-fold.cc.
(simplify_builtin_call): Try to optimize memcpy/memset.
(pass_forwprop::execute): Try to optimize memcpy like assignment
from a previous memset.
gcc/testsuite/ChangeLog:
* gcc.dg/pr78408-1.c: Update scan to forwprop1 only.
Signed-off-by: Andrew Pinski <quic_apin...@quicinc.com>
---
gcc/gimple-fold.cc | 168 -----------------------------
gcc/testsuite/gcc.dg/pr78408-1.c | 3 +-
gcc/tree-ssa-forwprop.cc | 176 +++++++++++++++++++++++++++++++
3 files changed, 177 insertions(+), 170 deletions(-)
diff --git a/gcc/gimple-fold.cc b/gcc/gimple-fold.cc
index 009c5737ef9..b74fb8bb50c 100644
--- a/gcc/gimple-fold.cc
+++ b/gcc/gimple-fold.cc
@@ -894,155 +894,6 @@ size_must_be_zero_p (tree size)
return vr.zero_p ();
}
-/* Optimize
- a = {};
- b = a;
- into
- a = {};
- b = {};
- Similarly for memset (&a, ..., sizeof (a)); instead of a = {};
- and/or memcpy (&b, &a, sizeof (a)); instead of b = a; */
-
-static bool
-optimize_memcpy_to_memset (gimple_stmt_iterator *gsip, tree dest, tree src,
tree len)
-{
- ao_ref read;
- gimple *stmt = gsi_stmt (*gsip);
- if (gimple_has_volatile_ops (stmt))
- return false;
-
-
- tree src2 = NULL_TREE, len2 = NULL_TREE;
- poly_int64 offset, offset2;
- tree val = integer_zero_node;
- bool len_was_null = len == NULL_TREE;
- if (len == NULL_TREE)
- len = (TREE_CODE (src) == COMPONENT_REF
- ? DECL_SIZE_UNIT (TREE_OPERAND (src, 1))
- : TYPE_SIZE_UNIT (TREE_TYPE (src)));
- if (len == NULL_TREE
- || !poly_int_tree_p (len))
- return false;
-
- ao_ref_init (&read, src);
- tree vuse = gimple_vuse (stmt);
- gimple *defstmt;
- do {
- if (vuse == NULL || TREE_CODE (vuse) != SSA_NAME)
- return false;
- defstmt = SSA_NAME_DEF_STMT (vuse);
- if (is_a <gphi*>(defstmt))
- return false;
-
- /* If the len was null, then we can use TBBA. */
- if (stmt_may_clobber_ref_p_1 (defstmt, &read,
- /* tbaa_p = */ len_was_null))
- break;
- vuse = gimple_vuse (defstmt);
- } while (true);
-
- if (gimple_store_p (defstmt)
- && gimple_assign_single_p (defstmt)
- && TREE_CODE (gimple_assign_rhs1 (defstmt)) == STRING_CST
- && !gimple_clobber_p (defstmt))
- {
- tree str = gimple_assign_rhs1 (defstmt);
- src2 = gimple_assign_lhs (defstmt);
- /* The string must contain all null char's for now. */
- for (int i = 0; i < TREE_STRING_LENGTH (str); i++)
- {
- if (TREE_STRING_POINTER (str)[i] != 0)
- {
- src2 = NULL_TREE;
- break;
- }
- }
- }
- else if (gimple_store_p (defstmt)
- && gimple_assign_single_p (defstmt)
- && TREE_CODE (gimple_assign_rhs1 (defstmt)) == CONSTRUCTOR
- && !gimple_clobber_p (defstmt))
- src2 = gimple_assign_lhs (defstmt);
- else if (gimple_call_builtin_p (defstmt, BUILT_IN_MEMSET)
- && TREE_CODE (gimple_call_arg (defstmt, 0)) == ADDR_EXPR
- && TREE_CODE (gimple_call_arg (defstmt, 1)) == INTEGER_CST)
- {
- src2 = TREE_OPERAND (gimple_call_arg (defstmt, 0), 0);
- len2 = gimple_call_arg (defstmt, 2);
- val = gimple_call_arg (defstmt, 1);
- /* For non-0 val, we'd have to transform stmt from assignment
- into memset (only if dest is addressable). */
- if (!integer_zerop (val) && is_gimple_assign (stmt))
- src2 = NULL_TREE;
- }
-
- if (src2 == NULL_TREE)
- return false;
-
- if (len2 == NULL_TREE)
- len2 = (TREE_CODE (src2) == COMPONENT_REF
- ? DECL_SIZE_UNIT (TREE_OPERAND (src2, 1))
- : TYPE_SIZE_UNIT (TREE_TYPE (src2)));
- if (len2 == NULL_TREE
- || !poly_int_tree_p (len2))
- return false;
-
- src = get_addr_base_and_unit_offset (src, &offset);
- src2 = get_addr_base_and_unit_offset (src2, &offset2);
- if (src == NULL_TREE
- || src2 == NULL_TREE
- || maybe_lt (offset, offset2))
- return false;
-
- if (!operand_equal_p (src, src2, 0))
- return false;
-
- /* [ src + offset2, src + offset2 + len2 - 1 ] is set to val.
- Make sure that
- [ src + offset, src + offset + len - 1 ] is a subset of that. */
- if (maybe_gt (wi::to_poly_offset (len) + (offset - offset2),
- wi::to_poly_offset (len2)))
- return false;
-
- if (dump_file && (dump_flags & TDF_DETAILS))
- {
- fprintf (dump_file, "Simplified\n ");
- print_gimple_stmt (dump_file, stmt, 0, dump_flags);
- fprintf (dump_file, "after previous\n ");
- print_gimple_stmt (dump_file, defstmt, 0, dump_flags);
- }
-
- /* For simplicity, don't change the kind of the stmt,
- turn dest = src; into dest = {}; and memcpy (&dest, &src, len);
- into memset (&dest, val, len);
- In theory we could change dest = src into memset if dest
- is addressable (maybe beneficial if val is not 0), or
- memcpy (&dest, &src, len) into dest = {} if len is the size
- of dest, dest isn't volatile. */
- if (is_gimple_assign (stmt))
- {
- tree ctor = build_constructor (TREE_TYPE (dest), NULL);
- gimple_assign_set_rhs_from_tree (gsip, ctor);
- update_stmt (stmt);
- }
- else /* If stmt is memcpy, transform it into memset. */
- {
- gcall *call = as_a <gcall *> (stmt);
- tree fndecl = builtin_decl_implicit (BUILT_IN_MEMSET);
- gimple_call_set_fndecl (call, fndecl);
- gimple_call_set_fntype (call, TREE_TYPE (fndecl));
- gimple_call_set_arg (call, 1, val);
- update_stmt (stmt);
- }
-
- if (dump_file && (dump_flags & TDF_DETAILS))
- {
- fprintf (dump_file, "into\n ");
- print_gimple_stmt (dump_file, stmt, 0, dump_flags);
- }
- return true;
-}
-
/* Fold function call to builtin mem{{,p}cpy,move}. Try to detect and
diagnose (otherwise undefined) overlapping copies without preventing
folding. When folded, GCC guarantees that overlapping memcpy has
@@ -1322,15 +1173,6 @@ gimple_fold_builtin_memory_op (gimple_stmt_iterator *gsi,
return false;
}
- /* Try to optimize the memcpy to memset if src and dest are addresses. */
- if (code != BUILT_IN_MEMPCPY
- && TREE_CODE (dest) == ADDR_EXPR
- && TREE_CODE (src) == ADDR_EXPR
- && TREE_CODE (len) == INTEGER_CST
- && optimize_memcpy_to_memset (gsi, TREE_OPERAND (dest, 0),
- TREE_OPERAND (src, 0), len))
- return true;
-
if (!tree_fits_shwi_p (len))
return false;
if (!srctype
@@ -6734,16 +6576,6 @@ fold_stmt_1 (gimple_stmt_iterator *gsi, bool inplace,
tree (*valueize) (tree),
{
case GIMPLE_ASSIGN:
{
- if (gimple_assign_load_p (stmt) && gimple_store_p (stmt))
- {
- if (optimize_memcpy_to_memset (gsi, gimple_assign_lhs (stmt),
- gimple_assign_rhs1 (stmt),
- /* len = */NULL_TREE))
- {
- changed = true;
- break;
- }
- }
/* Try to canonicalize for boolean-typed X the comparisons
X == 0, X == 1, X != 0, and X != 1. */
if (gimple_assign_rhs_code (stmt) == EQ_EXPR
diff --git a/gcc/testsuite/gcc.dg/pr78408-1.c b/gcc/testsuite/gcc.dg/pr78408-1.c
index a2d9306848b..feb9180c545 100644
--- a/gcc/testsuite/gcc.dg/pr78408-1.c
+++ b/gcc/testsuite/gcc.dg/pr78408-1.c
@@ -1,8 +1,7 @@
/* PR c/78408 */
/* { dg-do compile { target size32plus } } */
/* { dg-options "-O2 -fdump-tree-ccp-details -fdump-tree-forwprop-details" } */
-/* { dg-final { scan-tree-dump-times "after previous" 1 "ccp1" } } */
-/* { dg-final { scan-tree-dump-times "after previous" 16 "forwprop1" } } */
+/* { dg-final { scan-tree-dump-times "after previous" 17 "forwprop1" } } */
struct S { char a[33]; };
struct T { char a[65536]; };
diff --git a/gcc/tree-ssa-forwprop.cc b/gcc/tree-ssa-forwprop.cc
index 3187314390f..71de99f46ff 100644
--- a/gcc/tree-ssa-forwprop.cc
+++ b/gcc/tree-ssa-forwprop.cc
@@ -1183,6 +1183,155 @@ constant_pointer_difference (tree p1, tree p2)
return NULL_TREE;
}
+
+/* Optimize
+ a = {};
+ b = a;
+ into
+ a = {};
+ b = {};
+ Similarly for memset (&a, ..., sizeof (a)); instead of a = {};
+ and/or memcpy (&b, &a, sizeof (a)); instead of b = a; */
+
+static bool
+optimize_memcpy_to_memset (gimple_stmt_iterator *gsip, tree dest, tree src,
tree len)
+{
+ ao_ref read;
+ gimple *stmt = gsi_stmt (*gsip);
+ if (gimple_has_volatile_ops (stmt))
+ return false;
+
+ tree src2 = NULL_TREE, len2 = NULL_TREE;
+ poly_int64 offset, offset2;
+ tree val = integer_zero_node;
+ bool len_was_null = len == NULL_TREE;
+ if (len == NULL_TREE)
+ len = (TREE_CODE (src) == COMPONENT_REF
+ ? DECL_SIZE_UNIT (TREE_OPERAND (src, 1))
+ : TYPE_SIZE_UNIT (TREE_TYPE (src)));
+ if (len == NULL_TREE
+ || !poly_int_tree_p (len))
+ return false;
+
+ ao_ref_init (&read, src);
+ tree vuse = gimple_vuse (stmt);
+ gimple *defstmt;
+ do {
+ if (vuse == NULL || TREE_CODE (vuse) != SSA_NAME)
+ return false;
+ defstmt = SSA_NAME_DEF_STMT (vuse);
+ if (is_a <gphi*>(defstmt))
+ return false;
+
+ /* If the len was null, then we can use TBBA. */
+ if (stmt_may_clobber_ref_p_1 (defstmt, &read,
+ /* tbaa_p = */ len_was_null))
+ break;
+ vuse = gimple_vuse (defstmt);
+ } while (true);
+
+ if (gimple_store_p (defstmt)
+ && gimple_assign_single_p (defstmt)
+ && TREE_CODE (gimple_assign_rhs1 (defstmt)) == STRING_CST
+ && !gimple_clobber_p (defstmt))
+ {
+ tree str = gimple_assign_rhs1 (defstmt);
+ src2 = gimple_assign_lhs (defstmt);
+ /* The string must contain all null char's for now. */
+ for (int i = 0; i < TREE_STRING_LENGTH (str); i++)
+ {
+ if (TREE_STRING_POINTER (str)[i] != 0)
+ {
+ src2 = NULL_TREE;
+ break;
+ }
+ }
+ }
+ else if (gimple_store_p (defstmt)
+ && gimple_assign_single_p (defstmt)
+ && TREE_CODE (gimple_assign_rhs1 (defstmt)) == CONSTRUCTOR
+ && !gimple_clobber_p (defstmt))
+ src2 = gimple_assign_lhs (defstmt);
+ else if (gimple_call_builtin_p (defstmt, BUILT_IN_MEMSET)
+ && TREE_CODE (gimple_call_arg (defstmt, 0)) == ADDR_EXPR
+ && TREE_CODE (gimple_call_arg (defstmt, 1)) == INTEGER_CST)
+ {
+ src2 = TREE_OPERAND (gimple_call_arg (defstmt, 0), 0);
+ len2 = gimple_call_arg (defstmt, 2);
+ val = gimple_call_arg (defstmt, 1);
+ /* For non-0 val, we'd have to transform stmt from assignment
+ into memset (only if dest is addressable). */
+ if (!integer_zerop (val) && is_gimple_assign (stmt))
+ src2 = NULL_TREE;
+ }
+
+ if (src2 == NULL_TREE)
+ return false;
+
+ if (len2 == NULL_TREE)
+ len2 = (TREE_CODE (src2) == COMPONENT_REF
+ ? DECL_SIZE_UNIT (TREE_OPERAND (src2, 1))
+ : TYPE_SIZE_UNIT (TREE_TYPE (src2)));
+ if (len2 == NULL_TREE
+ || !poly_int_tree_p (len2))
+ return false;
+
+ src = get_addr_base_and_unit_offset (src, &offset);
+ src2 = get_addr_base_and_unit_offset (src2, &offset2);
+ if (src == NULL_TREE
+ || src2 == NULL_TREE
+ || maybe_lt (offset, offset2))
+ return false;
+
+ if (!operand_equal_p (src, src2, 0))
+ return false;
+
+ /* [ src + offset2, src + offset2 + len2 - 1 ] is set to val.
+ Make sure that
+ [ src + offset, src + offset + len - 1 ] is a subset of that. */
+ if (maybe_gt (wi::to_poly_offset (len) + (offset - offset2),
+ wi::to_poly_offset (len2)))
+ return false;
+
+ if (dump_file && (dump_flags & TDF_DETAILS))
+ {
+ fprintf (dump_file, "Simplified\n ");
+ print_gimple_stmt (dump_file, stmt, 0, dump_flags);
+ fprintf (dump_file, "after previous\n ");
+ print_gimple_stmt (dump_file, defstmt, 0, dump_flags);
+ }
+
+ /* For simplicity, don't change the kind of the stmt,
+ turn dest = src; into dest = {}; and memcpy (&dest, &src, len);
+ into memset (&dest, val, len);
+ In theory we could change dest = src into memset if dest
+ is addressable (maybe beneficial if val is not 0), or
+ memcpy (&dest, &src, len) into dest = {} if len is the size
+ of dest, dest isn't volatile. */
+ if (is_gimple_assign (stmt))
+ {
+ tree ctor = build_constructor (TREE_TYPE (dest), NULL);
+ gimple_assign_set_rhs_from_tree (gsip, ctor);
+ update_stmt (stmt);
+ }
+ else /* If stmt is memcpy, transform it into memset. */
+ {
+ gcall *call = as_a <gcall *> (stmt);
+ tree fndecl = builtin_decl_implicit (BUILT_IN_MEMSET);
+ gimple_call_set_fndecl (call, fndecl);
+ gimple_call_set_fntype (call, TREE_TYPE (fndecl));
+ gimple_call_set_arg (call, 1, val);
+ update_stmt (stmt);
+ }
+
+ if (dump_file && (dump_flags & TDF_DETAILS))
+ {
+ fprintf (dump_file, "into\n ");
+ print_gimple_stmt (dump_file, stmt, 0, dump_flags);
+ }
+ return true;
+}
+
/* *GSI_P is a GIMPLE_CALL to a builtin function.
Optimize
memcpy (p, "abcd", 4);
@@ -1220,6 +1369,22 @@ simplify_builtin_call (gimple_stmt_iterator *gsi_p, tree
callee2)
switch (DECL_FUNCTION_CODE (callee2))
{
+ case BUILT_IN_MEMCPY:
+ if (gimple_call_num_args (stmt2) == 3)
+ {
+ tree dest = gimple_call_arg (stmt2, 0);
+ tree src = gimple_call_arg (stmt2, 1);
+ tree len = gimple_call_arg (stmt2, 2);
+ /* Try to optimize the memcpy to memset if src
+ and dest are addresses. */
+ if (TREE_CODE (dest) == ADDR_EXPR
+ && TREE_CODE (src) == ADDR_EXPR
+ && TREE_CODE (len) == INTEGER_CST
+ && optimize_memcpy_to_memset (gsi_p, TREE_OPERAND (dest, 0),
+ TREE_OPERAND (src, 0), len))
+ return true;
+ }
+ break;
case BUILT_IN_MEMCHR:
if (gimple_call_num_args (stmt2) == 3
&& (res = gimple_call_lhs (stmt2)) != nullptr
@@ -4532,6 +4697,17 @@ pass_forwprop::execute (function *fun)
{
tree rhs1 = gimple_assign_rhs1 (stmt);
enum tree_code code = gimple_assign_rhs_code (stmt);
+ if (gimple_assign_load_p (stmt) && gimple_store_p (stmt))
+ {
+ if (optimize_memcpy_to_memset (&gsi,
+ gimple_assign_lhs (stmt),
+ gimple_assign_rhs1
(stmt),
+ /* len = */NULL_TREE))
+ {
+ changed = true;
+ break;
+ }
+ }
if (TREE_CODE_CLASS (code) == tcc_comparison)
{
--
2.43.0
