Skip to content

R
riscv-gcc-1
Commit 319dcdd8 by Jeff Law Committed by Jeff Law
Options

Revert: 

	2015-05-04  Jeff Law  <law@redhat.com>

        * match.pd (bit_and (plus/minus (convert @0) (convert @1) mask): New
        simplifier to narrow arithmetic.
        * generic-match-head.c: (types_match, single_use): New functions.
        * gimple-match-head.c: (types_match, single_use): New functions.

	Revert:
	2015-05-04  Jeff Law  <law@redhat.com>
	* gcc.dg/tree-ssa/shorten-1.c: New test.

From-SVN: r222784
parent 4e417af3
Showing with 29 additions and 154 deletions
gcc/ChangeLog
2015-05-04 Jeff Law <law@redhat.com>
Revert:
2015-05-04 Jeff Law <law@redhat.com>
* match.pd (bit_and (plus/minus (convert @0) (convert @1) mask): New
simplifier to narrow arithmetic.
* generic-match-head.c: (types_match, single_use): New functions.
* gimple-match-head.c: (types_match, single_use): New functions.
2015-05-04 Kaz Kojima <kkojima@gcc.gnu.org>
PR target/65987
......
gcc/generic-match-head.c
......@@ -70,20 +70,4 @@ along with GCC; see the file COPYING3. If not see
#include "dumpfile.h"
#include "generic-match.h"
/* Routine to determine if the types T1 and T2 are effectively
the same for GENERIC. */
inline bool
types_match (tree t1, tree t2)
{
return TYPE_MAIN_VARIANT (t1) == TYPE_MAIN_VARIANT (t2);
}
/* Return if T has a single use. For GENERIC, we assume this is
always true. */
inline bool
single_use (tree t)
{
return true;
}
gcc/gimple-match-head.c
......@@ -861,21 +861,3 @@ do_valueize (tree (*valueize)(tree), tree op)
return op;
}
/* Routine to determine if the types T1 and T2 are effectively
the same for GIMPLE. */
inline bool
types_match (tree t1, tree t2)
{
return types_compatible_p (t1, t2);
}
/* Return if T has a single use. For GIMPLE, we also allow any
non-SSA_NAME (ie constants) and zero uses to cope with uses
that aren't linked up yet. */
inline bool
single_use (tree t)
{
return TREE_CODE (t) != SSA_NAME || has_zero_uses (t) || has_single_use (t);
}
gcc/match.pd
......@@ -289,7 +289,8 @@ along with GCC; see the file COPYING3. If not see
(if (((TREE_CODE (@1) == INTEGER_CST
&& INTEGRAL_TYPE_P (TREE_TYPE (@0))
&& int_fits_type_p (@1, TREE_TYPE (@0)))
|| types_match (TREE_TYPE (@0), TREE_TYPE (@1)))
|| (GIMPLE && types_compatible_p (TREE_TYPE (@0), TREE_TYPE (@1)))
|| (GENERIC && TREE_TYPE (@0) == TREE_TYPE (@1)))
/* ??? This transform conflicts with fold-const.c doing
Convert (T)(x & c) into (T)x & (T)c, if c is an integer
constants (if x has signed type, the sign bit cannot be set
......@@ -948,7 +949,8 @@ along with GCC; see the file COPYING3. If not see
/* Unordered tests if either argument is a NaN. */
(simplify
(bit_ior (unordered @0 @0) (unordered @1 @1))
(if (types_match (TREE_TYPE (@0), TREE_TYPE (@1)))
(if ((GIMPLE && types_compatible_p (TREE_TYPE (@0), TREE_TYPE (@1)))
|| (GENERIC && TREE_TYPE (@0) == TREE_TYPE (@1)))
(unordered @0 @1)))
(simplify
(bit_ior:c (unordered @0 @0) (unordered:c@2 @0 @1))
......@@ -1052,7 +1054,7 @@ along with GCC; see the file COPYING3. If not see
operation and convert the result to the desired type. */
(for op (plus minus)
(simplify
(convert (op@4 (convert@2 @0) (convert@3 @1)))
(convert (op (convert@2 @0) (convert@3 @1)))
(if (INTEGRAL_TYPE_P (type)
/* We check for type compatibility between @0 and @1 below,
so there's no need to check that @1/@3 are integral types. */
......@@ -1068,45 +1070,15 @@ along with GCC; see the file COPYING3. If not see
&& TYPE_PRECISION (type) == GET_MODE_PRECISION (TYPE_MODE (type))
/* The inner conversion must be a widening conversion. */
&& TYPE_PRECISION (TREE_TYPE (@2)) > TYPE_PRECISION (TREE_TYPE (@0))
&& types_match (TREE_TYPE (@0), TREE_TYPE (@1))
&& types_match (TREE_TYPE (@0), type)
&& single_use (@4))
&& ((GENERIC
&& (TYPE_MAIN_VARIANT (TREE_TYPE (@0))
== TYPE_MAIN_VARIANT (TREE_TYPE (@1)))
&& (TYPE_MAIN_VARIANT (TREE_TYPE (@0))
== TYPE_MAIN_VARIANT (type)))
|| (GIMPLE
&& types_compatible_p (TREE_TYPE (@0), TREE_TYPE (@1))
&& types_compatible_p (TREE_TYPE (@0), type))))
(if (TYPE_OVERFLOW_WRAPS (TREE_TYPE (@0)))
(convert (op @0 @1)))
(with { tree utype = unsigned_type_for (TREE_TYPE (@0)); }
(convert (op (convert:utype @0) (convert:utype @1)))))))
/* This is another case of narrowing, specifically when there's an outer
BIT_AND_EXPR which masks off bits outside the type of the innermost
operands. Like the previous case we have to convert the operands
to unsigned types to avoid introducing undefined behaviour for the
arithmetic operation. */
(for op (minus plus)
(simplify
(bit_and (op@5 (convert@2 @0) (convert@3 @1)) INTEGER_CST@4)
(if (INTEGRAL_TYPE_P (type)
/* We check for type compatibility between @0 and @1 below,
so there's no need to check that @1/@3 are integral types. */
&& INTEGRAL_TYPE_P (TREE_TYPE (@0))
&& INTEGRAL_TYPE_P (TREE_TYPE (@2))
/* The precision of the type of each operand must match the
precision of the mode of each operand, similarly for the
result. */
&& (TYPE_PRECISION (TREE_TYPE (@0))
== GET_MODE_PRECISION (TYPE_MODE (TREE_TYPE (@0))))
&& (TYPE_PRECISION (TREE_TYPE (@1))
== GET_MODE_PRECISION (TYPE_MODE (TREE_TYPE (@1))))
&& TYPE_PRECISION (type) == GET_MODE_PRECISION (TYPE_MODE (type))
/* The inner conversion must be a widening conversion. */
&& TYPE_PRECISION (TREE_TYPE (@2)) > TYPE_PRECISION (TREE_TYPE (@0))
&& types_match (TREE_TYPE (@0), TREE_TYPE (@1))
&& (tree_int_cst_min_precision (@4, UNSIGNED)
<= TYPE_PRECISION (TREE_TYPE (@0)))
&& single_use (@5))
(if (TYPE_OVERFLOW_WRAPS (TREE_TYPE (@0)))
(with { tree ntype = TREE_TYPE (@0); }
(convert (bit_and (op @0 @1) (convert:ntype @4)))))
(with { tree utype = unsigned_type_for (TREE_TYPE (@0)); }
(convert (bit_and (op (convert:utype @0) (convert:utype @1))
(convert:utype @4)))))))
gcc/testsuite/ChangeLog
2015-05-04 Jeff Law <law@redhat.com>
Revert:
2015-05-04 Jeff Law <law@redhat.com>
* gcc.dg/tree-ssa/shorten-1.c: New test.
2015-05-04 Paolo Carlini <paolo.carlini@oracle.com>
Jakub Jelinek <jakub@redhat.com>
......
gcc/testsuite/gcc.dg/tree-ssa/shorten-1.c deleted 100644 → 0
/* { dg-do compile } */
/* { dg-options "-O2 -fdump-tree-optimized" } */
extern const unsigned char mode_ibit[];
extern const unsigned char mode_fbit[];
extern const signed char smode_ibit[];
extern const signed char smode_fbit[];
/* We use bit-and rather than modulo to ensure we're actually
testing the desired match.pd pattern. */
unsigned char
muufubar (int indx)
{
int ret = (mode_fbit [indx] - mode_ibit [indx]) & 3;
return ret;
}
signed char
msufubar (int indx)
{
int ret = (mode_fbit [indx] - mode_ibit [indx]) & 3;
return ret;
}
unsigned char
musfubar (int indx)
{
int ret = (smode_fbit [indx] - smode_ibit [indx]) & 3;
return ret;
}
signed char
mssfubar (int indx)
{
int ret = (smode_fbit [indx] - smode_ibit [indx]) & 3;
return ret;
}
unsigned char
puufubar (int indx)
{
int ret = (mode_fbit [indx] + mode_ibit [indx]) & 3;
return ret;
}
signed char
psufubar (int indx)
{
int ret = (mode_fbit [indx] + mode_ibit [indx]) & 3;
return ret;
}
unsigned char
pusfubar (int indx)
{
int ret = (smode_fbit [indx] + smode_ibit [indx]) & 3;
return ret;
}
signed char
pssfubar (int indx)
{
int ret = (smode_fbit [indx] + smode_ibit [indx]) & 3;
return ret;
}
/* The shortening patterns in match.pd should arrange to do the
arithmetic in char modes and thus any casts to ints should
have been removed. */
/* { dg-final {scan-tree-dump-not "\\(int\\)" "optimized"} } */
/* We should have casted 4 operands from signed to unsigned char types. */
/* { dg-final {scan-tree-dump-times "\\(unsigned char\\)" 8 "optimized" } } */
/* And two return values should have been casted from unsigned char to
a normal char. */
/* { dg-final {scan-tree-dump-times "\\(signed char\\)" 4 "optimized" } } */
/* { dg-final { cleanup-tree-dump "optimized" } } */
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment