From 7b45d0dfeb5f855723a2603bb5ea6585438f224c Mon Sep 17 00:00:00 2001 From: Jakub Jelinek Date: Fri, 16 Dec 2016 16:57:43 +0100 Subject: [PATCH] re PR c/78408 (C loop initial declarations generate wrong code) PR c/78408 * tree-ssa-ccp.c: Include tree-dfa.h. (optimize_memcpy): New function. (pass_fold_builtins::execute): Use it. Remove useless conditional break after BUILT_IN_VA_*. * gcc.dg/pr78408-1.c: New test. * gcc.dg/pr78408-2.c: New test. From-SVN: r243753 --- gcc/ChangeLog | 8 ++ gcc/sanopt.c | 3 + gcc/testsuite/ChangeLog | 6 ++ gcc/testsuite/gcc.dg/pr78408-1.c | 88 ++++++++++++++++++++ gcc/testsuite/gcc.dg/pr78408-2.c | 39 +++++++++ gcc/tree-ssa-ccp.c | 134 ++++++++++++++++++++++++++++++- 6 files changed, 275 insertions(+), 3 deletions(-) create mode 100644 gcc/testsuite/gcc.dg/pr78408-1.c create mode 100644 gcc/testsuite/gcc.dg/pr78408-2.c diff --git a/gcc/ChangeLog b/gcc/ChangeLog index 2a443d0a499..84797ad7acb 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,3 +1,11 @@ +2016-12-16 Jakub Jelinek + + PR c/78408 + * tree-ssa-ccp.c: Include tree-dfa.h. + (optimize_memcpy): New function. + (pass_fold_builtins::execute): Use it. Remove useless conditional + break after BUILT_IN_VA_*. + 2016-12-16 Marek Polacek PR tree-optimization/78819 diff --git a/gcc/sanopt.c b/gcc/sanopt.c index 7fe8d32e39a..e72a49b6375 100644 --- a/gcc/sanopt.c +++ b/gcc/sanopt.c @@ -802,6 +802,9 @@ sanitize_asan_mark_poison (void) if (maybe_contains_asan_check (stmt)) { bitmap_set_bit (with_check, bb->index); +if (dump_file) +fprintf (dump_file, "setting bit %d\n", bb->index); + break; } } diff --git a/gcc/testsuite/ChangeLog b/gcc/testsuite/ChangeLog index 3307b2efce9..dc64b2c7f6d 100644 --- a/gcc/testsuite/ChangeLog +++ b/gcc/testsuite/ChangeLog @@ -1,3 +1,9 @@ +2016-12-16 Jakub Jelinek + + PR c/78408 + * gcc.dg/pr78408-1.c: New test. + * gcc.dg/pr78408-2.c: New test. + 2016-12-16 Marek Polacek PR tree-optimization/78819 diff --git a/gcc/testsuite/gcc.dg/pr78408-1.c b/gcc/testsuite/gcc.dg/pr78408-1.c new file mode 100644 index 00000000000..a7a772a2be7 --- /dev/null +++ b/gcc/testsuite/gcc.dg/pr78408-1.c @@ -0,0 +1,88 @@ +/* PR c/78408 */ +/* { dg-do compile } */ +/* { dg-options "-O2 -fdump-tree-fab1-details" } */ +/* { dg-final { scan-tree-dump-times "after previous" 17 "fab1" } } */ + +struct S { char a[32]; }; +struct T { char a[65536]; }; +void bar (int, struct S *, struct S *, struct T *, struct T *); +void baz (char *, char *); + +void +f1 (void) +{ + struct S a, b; + struct T c, d; + a = b = (struct S) {}; + c = d = (struct T) {}; + bar (1, &a, &b, &c, &d); +} + +void +f2 (void) +{ + struct S a, b; + struct T c, d; + b = (struct S) {}; + a = b; + d = (struct T) {}; + c = d; + bar (2, &a, &b, &c, &d); +} + +void +f3 (void) +{ + struct S a, b; + struct T c, d; + __builtin_memset (&b, 0, sizeof (b)); + a = b; + __builtin_memset (&d, 0, sizeof (d)); + c = d; + bar (3, &a, &b, &c, &d); +} + + +void +f4 (void) +{ + struct S a, b; + struct T c, d; + b = (struct S) {}; + __builtin_memcpy (&a, &b, sizeof (b)); + d = (struct T) {}; + __builtin_memcpy (&c, &d, sizeof (d)); + bar (4, &a, &b, &c, &d); +} + +void +f5 (void) +{ + struct S a, b; + struct T c, d; + __builtin_memset (&b, 0, sizeof (b)); + __builtin_memcpy (&a, &b, sizeof (b)); + __builtin_memset (&d, 0, sizeof (d)); + __builtin_memcpy (&c, &d, sizeof (d)); + bar (5, &a, &b, &c, &d); +} + +void +f6 (void) +{ + struct S a, b, e, g; + struct T c, d, f, h; + g = e = a = b = (struct S) {}; + h = f = c = d = (struct T) {}; + bar (6, &a, &b, &c, &d); + bar (6, &e, &g, &f, &h); +} + +void +f7 (void) +{ + char a[64], b[64]; + __builtin_memset (a + 13, 2, 27); + __builtin_memcpy (b + 4, a + 17, 23); + baz (a, b); +} diff --git a/gcc/testsuite/gcc.dg/pr78408-2.c b/gcc/testsuite/gcc.dg/pr78408-2.c new file mode 100644 index 00000000000..7870e4e7ca6 --- /dev/null +++ b/gcc/testsuite/gcc.dg/pr78408-2.c @@ -0,0 +1,39 @@ +/* PR c/78408 */ +/* { dg-do compile } */ +/* { dg-options "-O2 -fdump-tree-fab1-details" } */ +/* { dg-final { scan-tree-dump-not "after previous" "fab1" } } */ + +struct S { char a[32]; }; +struct T { char a[65536]; }; +void bar (int, struct S *, struct S *, struct T *, struct T *); +void baz (char *, char *); + +void +f1 (void) +{ + struct S a, b; + struct T c, d; + __builtin_memset (&b, 2, sizeof (b)); + a = b; + __builtin_memset (&d, 3, sizeof (d)); + c = d; + bar (3, &a, &b, &c, &d); +} + +void +f2 (void) +{ + char a[64], b[64]; + __builtin_memset (a + 13, 2, 27); + __builtin_memcpy (b + 4, a + 17, 24); + baz (a, b); +} + +void +f3 (void) +{ + char a[64], b[64]; + __builtin_memset (a + 13, 2, 27); + __builtin_memcpy (b + 4, a + 12, 5); + baz (a, b); +} diff --git a/gcc/tree-ssa-ccp.c b/gcc/tree-ssa-ccp.c index 084b2e1dace..fb90d02e996 100644 --- a/gcc/tree-ssa-ccp.c +++ b/gcc/tree-ssa-ccp.c @@ -143,6 +143,7 @@ along with GCC; see the file COPYING3. If not see #include "stor-layout.h" #include "optabs-query.h" #include "tree-ssa-ccp.h" +#include "tree-dfa.h" /* Possible lattice values. */ typedef enum @@ -2933,6 +2934,119 @@ optimize_atomic_bit_test_and (gimple_stmt_iterator *gsip, release_ssa_name (lhs); } +/* 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 void +optimize_memcpy (gimple_stmt_iterator *gsip, tree dest, tree src, tree len) +{ + gimple *stmt = gsi_stmt (*gsip); + if (gimple_has_volatile_ops (stmt)) + return; + + tree vuse = gimple_vuse (stmt); + if (vuse == NULL) + return; + + gimple *defstmt = SSA_NAME_DEF_STMT (vuse); + tree src2 = NULL_TREE, len2 = NULL_TREE; + HOST_WIDE_INT offset, offset2; + tree val = integer_zero_node; + 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; + + if (len == NULL_TREE) + len = (TREE_CODE (src) == COMPONENT_REF + ? DECL_SIZE_UNIT (TREE_OPERAND (src, 1)) + : TYPE_SIZE_UNIT (TREE_TYPE (src))); + if (len2 == NULL_TREE) + len2 = (TREE_CODE (src2) == COMPONENT_REF + ? DECL_SIZE_UNIT (TREE_OPERAND (src2, 1)) + : TYPE_SIZE_UNIT (TREE_TYPE (src2))); + if (len == NULL_TREE + || TREE_CODE (len) != INTEGER_CST + || len2 == NULL_TREE + || TREE_CODE (len2) != INTEGER_CST) + return; + + 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 + || offset < offset2) + return; + + if (!operand_equal_p (src, src2, 0)) + return; + + /* [ 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 (wi::to_offset (len) + (offset - offset2) > wi::to_offset (len2)) + return; + + 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 (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); + } +} + /* A simple pass that attempts to fold all builtin functions. This pass is run after we've propagated as many constants as we can. */ @@ -2999,6 +3113,9 @@ pass_fold_builtins::execute (function *fun) continue; } } + else if (gimple_assign_load_p (stmt) && gimple_store_p (stmt)) + optimize_memcpy (&i, gimple_assign_lhs (stmt), + gimple_assign_rhs1 (stmt), NULL_TREE); gsi_next (&i); continue; } @@ -3114,14 +3231,25 @@ pass_fold_builtins::execute (function *fun) false, false); break; + case BUILT_IN_MEMCPY: + if (gimple_call_builtin_p (stmt, BUILT_IN_NORMAL) + && TREE_CODE (gimple_call_arg (stmt, 0)) == ADDR_EXPR + && TREE_CODE (gimple_call_arg (stmt, 1)) == ADDR_EXPR + && TREE_CODE (gimple_call_arg (stmt, 2)) == INTEGER_CST) + { + tree dest = TREE_OPERAND (gimple_call_arg (stmt, 0), 0); + tree src = TREE_OPERAND (gimple_call_arg (stmt, 1), 0); + tree len = gimple_call_arg (stmt, 2); + optimize_memcpy (&i, dest, src, len); + } + break; + case BUILT_IN_VA_START: case BUILT_IN_VA_END: case BUILT_IN_VA_COPY: /* These shouldn't be folded before pass_stdarg. */ result = optimize_stdarg_builtin (stmt); - if (result) - break; - /* FALLTHRU */ + break; default:; } -- 2.30.2