From fdc46830f1b793dc791099acfadc3f0f8cc24c0e Mon Sep 17 00:00:00 2001 From: Richard Biener Date: Wed, 23 Feb 2022 13:47:01 +0100 Subject: [PATCH] middle-end/104644 - recursion with bswap match.pd pattern The following patch avoids infinite recursion during generic folding. The (cmp (bswap @0) INTEGER_CST@1) simplification relies on (bswap @1) actually being simplified, if it is not simplified, we just move the bswap from one operand to the other and if @0 is also INTEGER_CST, we apply the same rule next. The reason why bswap @1 isn't folded to INTEGER_CST is that the INTEGER_CST has TREE_OVERFLOW set on it and fold-const-call.cc predicate punts in such cases: static inline bool integer_cst_p (tree t) { return TREE_CODE (t) == INTEGER_CST && !TREE_OVERFLOW (t); } The patch uses ! modifier to ensure the bswap is simplified and extends support to GENERIC by means of requiring !EXPR_P which is not perfect but a conservative approximation. 2022-02-22 Richard Biener PR tree-optimization/104644 * doc/match-and-simplify.texi: Amend ! documentation. * genmatch.cc (expr::gen_transform): Code-generate ! support for GENERIC. (parser::parse_expr): Allow ! for GENERIC. * match.pd (cmp (bswap @0) INTEGER_CST@1): Use ! modifier on bswap. * gcc.dg/pr104644.c: New test. Co-Authored-by: Jakub Jelinek --- gcc/doc/match-and-simplify.texi | 6 ++++-- gcc/genmatch.cc | 20 +++++++++----------- gcc/match.pd | 2 +- gcc/testsuite/gcc.dg/pr104644.c | 9 +++++++++ 4 files changed, 23 insertions(+), 14 deletions(-) create mode 100644 gcc/testsuite/gcc.dg/pr104644.c diff --git a/gcc/doc/match-and-simplify.texi b/gcc/doc/match-and-simplify.texi index 63a73ae047c..055a5308e7d 100644 --- a/gcc/doc/match-and-simplify.texi +++ b/gcc/doc/match-and-simplify.texi @@ -374,8 +374,10 @@ for example which moves the outer @code{plus} operation to the inner arms of the @code{vec_cond} expression but only if the actual plus -operations both simplify. Note this is currently only supported -for code generation targeting @code{GIMPLE}. +operations both simplify. Note that on @code{GENERIC} a simple +operand means that the result satisfies @code{!EXPR_P} which +can be limiting if the operation itself simplifies but the +remaining operand is an (unrelated) expression. As intermediate conversions are often optional there is a way to avoid the need to repeat patterns both with and without such diff --git a/gcc/genmatch.cc b/gcc/genmatch.cc index 97f6f00fa68..2eda7300821 100644 --- a/gcc/genmatch.cc +++ b/gcc/genmatch.cc @@ -2553,19 +2553,20 @@ expr::gen_transform (FILE *f, int indent, const char *dest, bool gimple, fprintf_indent (f, indent, "_r%d = fold_build%d_loc (loc, %s, %s", depth, ops.length(), opr_name, type); else - { - fprintf_indent (f, indent, "{\n"); - fprintf_indent (f, indent, " _r%d = maybe_build_call_expr_loc (loc, " - "%s, %s, %d", depth, opr_name, type, ops.length()); - } + fprintf_indent (f, indent, "_r%d = maybe_build_call_expr_loc (loc, " + "%s, %s, %d", depth, opr_name, type, ops.length()); for (unsigned i = 0; i < ops.length (); ++i) fprintf (f, ", _o%d[%u]", depth, i); fprintf (f, ");\n"); if (opr->kind != id_base::CODE) { - fprintf_indent (f, indent, " if (!_r%d)\n", depth); - fprintf_indent (f, indent, " goto %s;\n", fail_label); - fprintf_indent (f, indent, "}\n"); + fprintf_indent (f, indent, "if (!_r%d)\n", depth); + fprintf_indent (f, indent, " goto %s;\n", fail_label); + } + if (force_leaf) + { + fprintf_indent (f, indent, "if (EXPR_P (_r%d))\n", depth); + fprintf_indent (f, indent, " goto %s;\n", fail_label); } if (*opr == CONVERT_EXPR) { @@ -4297,9 +4298,6 @@ parser::parse_expr () && token->type == CPP_NOT && !(token->flags & PREV_WHITE)) { - if (!gimple) - fatal_at (token, "forcing simplification to a leaf is not supported " - "for GENERIC"); eat_token (CPP_NOT); e->force_leaf = true; } diff --git a/gcc/match.pd b/gcc/match.pd index cad61848daa..cf78a11ddd4 100644 --- a/gcc/match.pd +++ b/gcc/match.pd @@ -3962,7 +3962,7 @@ DEFINE_INT_AND_FLOAT_ROUND_FN (RINT) (simplify (cmp (bswap @0) INTEGER_CST@1) (with { tree ctype = TREE_TYPE (@1); } - (cmp (convert:ctype @0) (bswap @1))))) + (cmp (convert:ctype @0) (bswap! @1))))) /* (bswap(x) >> C1) & C2 can sometimes be simplified to (x >> C3) & C2. */ (simplify (bit_and (convert1? (rshift@0 (convert2? (bswap@4 @1)) INTEGER_CST@2)) diff --git a/gcc/testsuite/gcc.dg/pr104644.c b/gcc/testsuite/gcc.dg/pr104644.c new file mode 100644 index 00000000000..70bf3a49647 --- /dev/null +++ b/gcc/testsuite/gcc.dg/pr104644.c @@ -0,0 +1,9 @@ +/* PR tree-optimization/104644 */ +/* { dg-do compile } */ +/* { dg-options "-Wno-overflow" } */ + +int +foo (void) +{ + return __builtin_bswap16 (1.31072e+5f) != (signed char) 1.31072e+5f; +}