procyberian/gcc
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

fold-const: Handle AND, IOR, XOR with stepped vectors [PR112971].

Browse source 
Found in PR112971 this patch adds folding support for bitwise operations
of const duplicate zero/one vectors with stepped vectors.
On riscv we have the situation that a folding would perpetually continue
without simplifying because e.g. {0, 0, 0, ...} & {7, 6, 5, ...} would
not be folded to {0, 0, 0, ...}.

gcc/ChangeLog:

	PR middle-end/112971

	* fold-const.cc (simplify_const_binop): New function for binop
	simplification of two constant vectors when element-wise
	handling is not necessary.
	(const_binop): Call new function.

gcc/testsuite/ChangeLog:

	* gcc.target/riscv/rvv/autovec/pr112971.c: New test.
This commit is contained in:
Robin Dapp 2024-01-15 16:23:30 +01:00 • committed by Robin Dapp
parent 90880e117a
commit 660e17f006
2 changed files with 49 additions and 0 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

31
gcc/fold-const.cc
View file

@ -1343,6 +1343,29 @@ distributes_over_addition_p (tree_code op, int opno)
}
}
/* OP is the INDEXth operand to CODE (counting from zero) and OTHER_OP
is the other operand. Try to use the value of OP to simplify the
operation in one step, without having to process individual elements. */
static tree
simplify_const_binop (tree_code code, tree op, tree other_op,
int index ATTRIBUTE_UNUSED)
{
/* AND, IOR as well as XOR with a zerop can be simplified directly. */
if (TREE_CODE (op) == VECTOR_CST && TREE_CODE (other_op) == VECTOR_CST)
{
if (integer_zerop (other_op))
{
if (code == BIT_IOR_EXPR || code == BIT_XOR_EXPR)
return op;
else if (code == BIT_AND_EXPR)
return other_op;
}
}
return NULL_TREE;
}
/* Combine two constants ARG1 and ARG2 under operation CODE to produce a new
constant. We assume ARG1 and ARG2 have the same data type, or at least
are the same kind of constant and the same machine mode. Return zero if
@ -1646,6 +1669,14 @@ const_binop (enum tree_code code, tree arg1, tree arg2)
return build_complex (type, real, imag);
}
tree simplified;
if ((simplified = simplify_const_binop (code, arg1, arg2, 0)))
return simplified;
if (commutative_tree_code (code)
&& (simplified = simplify_const_binop (code, arg2, arg1, 1)))
return simplified;
if (TREE_CODE (arg1) == VECTOR_CST
&& TREE_CODE (arg2) == VECTOR_CST
&& known_eq (TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg1)),

18
gcc/testsuite/gcc.target/riscv/rvv/autovec/pr112971.c Normal file
View file

@ -0,0 +1,18 @@
/* { dg-do compile } */
/* { dg-options "-march=rv64gcv_zvl256b -mabi=lp64d -O3 -fno-vect-cost-model" } */
int a;
short b[9];
char c, d;
void e() {
d = 0;
for (;; d++) {
if (b[d])
break;
a = 8;
for (; a >= 0; a--) {
char *f = &c;
*f &= d == (a & d);
}
}
}