git
/
gcc
mirror of git://gcc.gnu.org/git/gcc.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

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
This commit is contained in:
Jakub Jelinek 2016-12-16 16:57:43 +01:00 committed by Jakub Jelinek
parent 6b520e8d4a
commit 7b45d0dfeb
6 changed files with 275 additions and 3 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
gcc/ChangeLog
View File

@ -1,3 +1,11 @@
2016-12-16 Jakub Jelinek <jakub@redhat.com>
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 <polacek@redhat.com>
PR tree-optimization/78819

3
gcc/sanopt.c
View File

@ -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;
}
}

6
gcc/testsuite/ChangeLog
View File

@ -1,3 +1,9 @@
2016-12-16 Jakub Jelinek <jakub@redhat.com>
PR c/78408
* gcc.dg/pr78408-1.c: New test.
* gcc.dg/pr78408-2.c: New test.
2016-12-16 Marek Polacek <polacek@redhat.com>
PR tree-optimization/78819

88
gcc/testsuite/gcc.dg/pr78408-1.c Normal file
View File

@ -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);
}

39
gcc/testsuite/gcc.dg/pr78408-2.c Normal file
View File

@ -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);
}

134
gcc/tree-ssa-ccp.c
View File

@ -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 <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);
}
}
/* 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:;
}