* [PATCH 1/4] Canonicalize argument order for commutative functions @ 2021-11-10 12:48 Richard Sandiford 2021-11-11 10:57 ` Richard Biener 0 siblings, 1 reply; 4+ messages in thread From: Richard Sandiford @ 2021-11-10 12:48 UTC (permalink / raw) To: gcc-patches This patch uses information about internal functions to canonicalize the argument order of calls. Tested on aarch64-linux-gnu and x86_64-linux-gnu. OK to install? Richard gcc/ * gimple-fold.c: Include internal-fn.h. (fold_stmt_1): If a function maps to an internal one, use first_commutative_argument to canonicalize the order of commutative arguments. gcc/testsuite/ * gcc.dg/fmax-fmin-1.c: New test. --- gcc/gimple-fold.c | 25 ++++++++++++++++++++++--- gcc/testsuite/gcc.dg/fmax-fmin-1.c | 18 ++++++++++++++++++ 2 files changed, 40 insertions(+), 3 deletions(-) create mode 100644 gcc/testsuite/gcc.dg/fmax-fmin-1.c diff --git a/gcc/gimple-fold.c b/gcc/gimple-fold.c index a937f130815..6a7d4507c89 100644 --- a/gcc/gimple-fold.c +++ b/gcc/gimple-fold.c @@ -69,6 +69,7 @@ along with GCC; see the file COPYING3. If not see #include "varasm.h" #include "memmodel.h" #include "optabs.h" +#include "internal-fn.h" enum strlen_range_kind { /* Compute the exact constant string length. */ @@ -6140,18 +6141,36 @@ fold_stmt_1 (gimple_stmt_iterator *gsi, bool inplace, tree (*valueize) (tree)) break; case GIMPLE_CALL: { - for (i = 0; i < gimple_call_num_args (stmt); ++i) + gcall *call = as_a<gcall *> (stmt); + for (i = 0; i < gimple_call_num_args (call); ++i) { - tree *arg = gimple_call_arg_ptr (stmt, i); + tree *arg = gimple_call_arg_ptr (call, i); if (REFERENCE_CLASS_P (*arg) && maybe_canonicalize_mem_ref_addr (arg)) changed = true; } - tree *lhs = gimple_call_lhs_ptr (stmt); + tree *lhs = gimple_call_lhs_ptr (call); if (*lhs && REFERENCE_CLASS_P (*lhs) && maybe_canonicalize_mem_ref_addr (lhs)) changed = true; + if (*lhs) + { + combined_fn cfn = gimple_call_combined_fn (call); + internal_fn ifn = associated_internal_fn (cfn, TREE_TYPE (*lhs)); + int opno = first_commutative_argument (ifn); + if (opno >= 0) + { + tree arg1 = gimple_call_arg (call, opno); + tree arg2 = gimple_call_arg (call, opno + 1); + if (tree_swap_operands_p (arg1, arg2)) + { + gimple_call_set_arg (call, opno, arg2); + gimple_call_set_arg (call, opno + 1, arg1); + changed = true; + } + } + } break; } case GIMPLE_ASM: diff --git a/gcc/testsuite/gcc.dg/fmax-fmin-1.c b/gcc/testsuite/gcc.dg/fmax-fmin-1.c new file mode 100644 index 00000000000..e7e0518d8bb --- /dev/null +++ b/gcc/testsuite/gcc.dg/fmax-fmin-1.c @@ -0,0 +1,18 @@ +/* { dg-options "-O -fdump-tree-optimized" } */ + +void +f1 (double *res, double x, double y) +{ + res[0] = __builtin_fmax (x, y); + res[1] = __builtin_fmax (y, x); +} + +void +f2 (double *res, double x, double y) +{ + res[0] = __builtin_fmin (x, y); + res[1] = __builtin_fmin (y, x); +} + +/* { dg-final { scan-tree-dump-times {__builtin_fmax} 1 "optimized" } } */ +/* { dg-final { scan-tree-dump-times {__builtin_fmin} 1 "optimized" } } */ -- 2.25.1 ^ permalink raw reply [flat|nested] 4+ messages in thread
* Re: [PATCH 1/4] Canonicalize argument order for commutative functions 2021-11-10 12:48 [PATCH 1/4] Canonicalize argument order for commutative functions Richard Sandiford @ 2021-11-11 10:57 ` Richard Biener 2021-11-29 15:40 ` Richard Sandiford 0 siblings, 1 reply; 4+ messages in thread From: Richard Biener @ 2021-11-11 10:57 UTC (permalink / raw) To: Richard Sandiford, GCC Patches On Wed, Nov 10, 2021 at 1:50 PM Richard Sandiford via Gcc-patches <gcc-patches@gcc.gnu.org> wrote: > > This patch uses information about internal functions to canonicalize > the argument order of calls. > > Tested on aarch64-linux-gnu and x86_64-linux-gnu. OK to install? OK. Note the gimple_resimplifyN functions also canonicalize operand order, currently for is_tree_code only: /* Canonicalize operand order. */ bool canonicalized = false; if (res_op->code.is_tree_code () && (TREE_CODE_CLASS ((enum tree_code) res_op->code) == tcc_comparison || commutative_tree_code (res_op->code)) && tree_swap_operands_p (res_op->ops[0], res_op->ops[1])) { std::swap (res_op->ops[0], res_op->ops[1]); if (TREE_CODE_CLASS ((enum tree_code) res_op->code) == tcc_comparison) res_op->code = swap_tree_comparison (res_op->code); canonicalized = true; } that's maybe not the best place. The function assumes the operands are already valueized, so it maybe should be valueization that does the canonicalization - but I think doing it elsewhere made operand order unreliable (we do end up with non-canonical order in the IL sometimes). So maybe you should amend the code in resimplifyN as well. Richard. > Richard > > > gcc/ > * gimple-fold.c: Include internal-fn.h. > (fold_stmt_1): If a function maps to an internal one, use > first_commutative_argument to canonicalize the order of > commutative arguments. > > gcc/testsuite/ > * gcc.dg/fmax-fmin-1.c: New test. > --- > gcc/gimple-fold.c | 25 ++++++++++++++++++++++--- > gcc/testsuite/gcc.dg/fmax-fmin-1.c | 18 ++++++++++++++++++ > 2 files changed, 40 insertions(+), 3 deletions(-) > create mode 100644 gcc/testsuite/gcc.dg/fmax-fmin-1.c > > diff --git a/gcc/gimple-fold.c b/gcc/gimple-fold.c > index a937f130815..6a7d4507c89 100644 > --- a/gcc/gimple-fold.c > +++ b/gcc/gimple-fold.c > @@ -69,6 +69,7 @@ along with GCC; see the file COPYING3. If not see > #include "varasm.h" > #include "memmodel.h" > #include "optabs.h" > +#include "internal-fn.h" > > enum strlen_range_kind { > /* Compute the exact constant string length. */ > @@ -6140,18 +6141,36 @@ fold_stmt_1 (gimple_stmt_iterator *gsi, bool inplace, tree (*valueize) (tree)) > break; > case GIMPLE_CALL: > { > - for (i = 0; i < gimple_call_num_args (stmt); ++i) > + gcall *call = as_a<gcall *> (stmt); > + for (i = 0; i < gimple_call_num_args (call); ++i) > { > - tree *arg = gimple_call_arg_ptr (stmt, i); > + tree *arg = gimple_call_arg_ptr (call, i); > if (REFERENCE_CLASS_P (*arg) > && maybe_canonicalize_mem_ref_addr (arg)) > changed = true; > } > - tree *lhs = gimple_call_lhs_ptr (stmt); > + tree *lhs = gimple_call_lhs_ptr (call); > if (*lhs > && REFERENCE_CLASS_P (*lhs) > && maybe_canonicalize_mem_ref_addr (lhs)) > changed = true; > + if (*lhs) > + { > + combined_fn cfn = gimple_call_combined_fn (call); > + internal_fn ifn = associated_internal_fn (cfn, TREE_TYPE (*lhs)); > + int opno = first_commutative_argument (ifn); > + if (opno >= 0) > + { > + tree arg1 = gimple_call_arg (call, opno); > + tree arg2 = gimple_call_arg (call, opno + 1); > + if (tree_swap_operands_p (arg1, arg2)) > + { > + gimple_call_set_arg (call, opno, arg2); > + gimple_call_set_arg (call, opno + 1, arg1); > + changed = true; > + } > + } > + } > break; > } > case GIMPLE_ASM: > diff --git a/gcc/testsuite/gcc.dg/fmax-fmin-1.c b/gcc/testsuite/gcc.dg/fmax-fmin-1.c > new file mode 100644 > index 00000000000..e7e0518d8bb > --- /dev/null > +++ b/gcc/testsuite/gcc.dg/fmax-fmin-1.c > @@ -0,0 +1,18 @@ > +/* { dg-options "-O -fdump-tree-optimized" } */ > + > +void > +f1 (double *res, double x, double y) > +{ > + res[0] = __builtin_fmax (x, y); > + res[1] = __builtin_fmax (y, x); > +} > + > +void > +f2 (double *res, double x, double y) > +{ > + res[0] = __builtin_fmin (x, y); > + res[1] = __builtin_fmin (y, x); > +} > + > +/* { dg-final { scan-tree-dump-times {__builtin_fmax} 1 "optimized" } } */ > +/* { dg-final { scan-tree-dump-times {__builtin_fmin} 1 "optimized" } } */ > -- > 2.25.1 > ^ permalink raw reply [flat|nested] 4+ messages in thread
* Re: [PATCH 1/4] Canonicalize argument order for commutative functions 2021-11-11 10:57 ` Richard Biener @ 2021-11-29 15:40 ` Richard Sandiford 2021-11-30 7:40 ` Richard Biener 0 siblings, 1 reply; 4+ messages in thread From: Richard Sandiford @ 2021-11-29 15:40 UTC (permalink / raw) To: Richard Biener; +Cc: GCC Patches Sorry for the slow response, was away last week. Richard Biener <richard.guenther@gmail.com> writes: > On Wed, Nov 10, 2021 at 1:50 PM Richard Sandiford via Gcc-patches > <gcc-patches@gcc.gnu.org> wrote: >> >> This patch uses information about internal functions to canonicalize >> the argument order of calls. >> >> Tested on aarch64-linux-gnu and x86_64-linux-gnu. OK to install? > > OK. Note the gimple_resimplifyN functions also canonicalize operand > order, currently for is_tree_code only: > > /* Canonicalize operand order. */ > bool canonicalized = false; > if (res_op->code.is_tree_code () > && (TREE_CODE_CLASS ((enum tree_code) res_op->code) == tcc_comparison > || commutative_tree_code (res_op->code)) > && tree_swap_operands_p (res_op->ops[0], res_op->ops[1])) > { > std::swap (res_op->ops[0], res_op->ops[1]); > if (TREE_CODE_CLASS ((enum tree_code) res_op->code) == tcc_comparison) > res_op->code = swap_tree_comparison (res_op->code); > canonicalized = true; > } > > that's maybe not the best place. The function assumes the operands > are already valueized, > so it maybe should be valueization that does the canonicalization - > but I think doing it > elsewhere made operand order unreliable (we do end up with > non-canonical order in > the IL sometimes). > > So maybe you should amend the code in resimplifyN as well. Hmm, yeah, thanks for the heads up. Does this updated version look OK? Tested as before. Thanks, Richard gcc/ * gimple-fold.c: Include internal-fn.h. (fold_stmt_1): If a function maps to an internal one, use first_commutative_argument to canonicalize the order of commutative arguments. * gimple-match-head.c (gimple_resimplify2, gimple_resimplify3) (gimple_resimplify4, gimple_resimplify5): Extend commutativity checks to functions. gcc/testsuite/ * gcc.dg/fmax-fmin-1.c: New test. --- gcc/gimple-fold.c | 25 ++++++++++++-- gcc/gimple-match-head.c | 52 ++++++++++++++++++++---------- gcc/testsuite/gcc.dg/fmax-fmin-1.c | 18 +++++++++++ 3 files changed, 75 insertions(+), 20 deletions(-) create mode 100644 gcc/testsuite/gcc.dg/fmax-fmin-1.c diff --git a/gcc/gimple-fold.c b/gcc/gimple-fold.c index 44fba12e150..1d8fd74f72c 100644 --- a/gcc/gimple-fold.c +++ b/gcc/gimple-fold.c @@ -69,6 +69,7 @@ along with GCC; see the file COPYING3. If not see #include "varasm.h" #include "memmodel.h" #include "optabs.h" +#include "internal-fn.h" enum strlen_range_kind { /* Compute the exact constant string length. */ @@ -6109,18 +6110,36 @@ fold_stmt_1 (gimple_stmt_iterator *gsi, bool inplace, tree (*valueize) (tree)) break; case GIMPLE_CALL: { - for (i = 0; i < gimple_call_num_args (stmt); ++i) + gcall *call = as_a<gcall *> (stmt); + for (i = 0; i < gimple_call_num_args (call); ++i) { - tree *arg = gimple_call_arg_ptr (stmt, i); + tree *arg = gimple_call_arg_ptr (call, i); if (REFERENCE_CLASS_P (*arg) && maybe_canonicalize_mem_ref_addr (arg)) changed = true; } - tree *lhs = gimple_call_lhs_ptr (stmt); + tree *lhs = gimple_call_lhs_ptr (call); if (*lhs && REFERENCE_CLASS_P (*lhs) && maybe_canonicalize_mem_ref_addr (lhs)) changed = true; + if (*lhs) + { + combined_fn cfn = gimple_call_combined_fn (call); + internal_fn ifn = associated_internal_fn (cfn, TREE_TYPE (*lhs)); + int opno = first_commutative_argument (ifn); + if (opno >= 0) + { + tree arg1 = gimple_call_arg (call, opno); + tree arg2 = gimple_call_arg (call, opno + 1); + if (tree_swap_operands_p (arg1, arg2)) + { + gimple_call_set_arg (call, opno, arg2); + gimple_call_set_arg (call, opno + 1, arg1); + changed = true; + } + } + } break; } case GIMPLE_ASM: diff --git a/gcc/gimple-match-head.c b/gcc/gimple-match-head.c index c481a625581..2d9364ca5de 100644 --- a/gcc/gimple-match-head.c +++ b/gcc/gimple-match-head.c @@ -294,18 +294,16 @@ gimple_resimplify2 (gimple_seq *seq, gimple_match_op *res_op, /* Canonicalize operand order. */ bool canonicalized = false; - if (res_op->code.is_tree_code ()) + bool is_comparison + = (res_op->code.is_tree_code () + && TREE_CODE_CLASS (tree_code (res_op->code)) == tcc_comparison); + if ((is_comparison || commutative_binary_op_p (res_op->code, res_op->type)) + && tree_swap_operands_p (res_op->ops[0], res_op->ops[1])) { - auto code = tree_code (res_op->code); - if ((TREE_CODE_CLASS (code) == tcc_comparison - || commutative_tree_code (code)) - && tree_swap_operands_p (res_op->ops[0], res_op->ops[1])) - { - std::swap (res_op->ops[0], res_op->ops[1]); - if (TREE_CODE_CLASS (code) == tcc_comparison) - res_op->code = swap_tree_comparison (code); - canonicalized = true; - } + std::swap (res_op->ops[0], res_op->ops[1]); + if (is_comparison) + res_op->code = swap_tree_comparison (tree_code (res_op->code)); + canonicalized = true; } /* Limit recursion, see gimple_resimplify1. */ @@ -376,11 +374,11 @@ gimple_resimplify3 (gimple_seq *seq, gimple_match_op *res_op, /* Canonicalize operand order. */ bool canonicalized = false; - if (res_op->code.is_tree_code () - && commutative_ternary_tree_code (tree_code (res_op->code)) - && tree_swap_operands_p (res_op->ops[0], res_op->ops[1])) + int argno = first_commutative_argument (res_op->code, res_op->type); + if (argno >= 0 + && tree_swap_operands_p (res_op->ops[argno], res_op->ops[argno + 1])) { - std::swap (res_op->ops[0], res_op->ops[1]); + std::swap (res_op->ops[argno], res_op->ops[argno + 1]); canonicalized = true; } @@ -424,6 +422,16 @@ gimple_resimplify4 (gimple_seq *seq, gimple_match_op *res_op, { /* No constant folding is defined for four-operand functions. */ + /* Canonicalize operand order. */ + bool canonicalized = false; + int argno = first_commutative_argument (res_op->code, res_op->type); + if (argno >= 0 + && tree_swap_operands_p (res_op->ops[argno], res_op->ops[argno + 1])) + { + std::swap (res_op->ops[argno], res_op->ops[argno + 1]); + canonicalized = true; + } + /* Limit recursion, see gimple_resimplify1. */ static unsigned depth; if (depth > 10) @@ -450,7 +458,7 @@ gimple_resimplify4 (gimple_seq *seq, gimple_match_op *res_op, if (maybe_resimplify_conditional_op (seq, res_op, valueize)) return true; - return false; + return canonicalized; } /* Helper that matches and simplifies the toplevel result from @@ -465,6 +473,16 @@ gimple_resimplify5 (gimple_seq *seq, gimple_match_op *res_op, { /* No constant folding is defined for five-operand functions. */ + /* Canonicalize operand order. */ + bool canonicalized = false; + int argno = first_commutative_argument (res_op->code, res_op->type); + if (argno >= 0 + && tree_swap_operands_p (res_op->ops[argno], res_op->ops[argno + 1])) + { + std::swap (res_op->ops[argno], res_op->ops[argno + 1]); + canonicalized = true; + } + gimple_match_op res_op2 (*res_op); if (gimple_simplify (&res_op2, seq, valueize, res_op->code, res_op->type, @@ -478,7 +496,7 @@ gimple_resimplify5 (gimple_seq *seq, gimple_match_op *res_op, if (maybe_resimplify_conditional_op (seq, res_op, valueize)) return true; - return false; + return canonicalized; } /* Match and simplify the toplevel valueized operation THIS. diff --git a/gcc/testsuite/gcc.dg/fmax-fmin-1.c b/gcc/testsuite/gcc.dg/fmax-fmin-1.c new file mode 100644 index 00000000000..e7e0518d8bb --- /dev/null +++ b/gcc/testsuite/gcc.dg/fmax-fmin-1.c @@ -0,0 +1,18 @@ +/* { dg-options "-O -fdump-tree-optimized" } */ + +void +f1 (double *res, double x, double y) +{ + res[0] = __builtin_fmax (x, y); + res[1] = __builtin_fmax (y, x); +} + +void +f2 (double *res, double x, double y) +{ + res[0] = __builtin_fmin (x, y); + res[1] = __builtin_fmin (y, x); +} + +/* { dg-final { scan-tree-dump-times {__builtin_fmax} 1 "optimized" } } */ +/* { dg-final { scan-tree-dump-times {__builtin_fmin} 1 "optimized" } } */ -- 2.25.1 ^ permalink raw reply [flat|nested] 4+ messages in thread
* Re: [PATCH 1/4] Canonicalize argument order for commutative functions 2021-11-29 15:40 ` Richard Sandiford @ 2021-11-30 7:40 ` Richard Biener 0 siblings, 0 replies; 4+ messages in thread From: Richard Biener @ 2021-11-30 7:40 UTC (permalink / raw) To: Richard Biener, GCC Patches, Richard Sandiford On Mon, Nov 29, 2021 at 4:40 PM Richard Sandiford <richard.sandiford@arm.com> wrote: > > Sorry for the slow response, was away last week. > > Richard Biener <richard.guenther@gmail.com> writes: > > On Wed, Nov 10, 2021 at 1:50 PM Richard Sandiford via Gcc-patches > > <gcc-patches@gcc.gnu.org> wrote: > >> > >> This patch uses information about internal functions to canonicalize > >> the argument order of calls. > >> > >> Tested on aarch64-linux-gnu and x86_64-linux-gnu. OK to install? > > > > OK. Note the gimple_resimplifyN functions also canonicalize operand > > order, currently for is_tree_code only: > > > > /* Canonicalize operand order. */ > > bool canonicalized = false; > > if (res_op->code.is_tree_code () > > && (TREE_CODE_CLASS ((enum tree_code) res_op->code) == tcc_comparison > > || commutative_tree_code (res_op->code)) > > && tree_swap_operands_p (res_op->ops[0], res_op->ops[1])) > > { > > std::swap (res_op->ops[0], res_op->ops[1]); > > if (TREE_CODE_CLASS ((enum tree_code) res_op->code) == tcc_comparison) > > res_op->code = swap_tree_comparison (res_op->code); > > canonicalized = true; > > } > > > > that's maybe not the best place. The function assumes the operands > > are already valueized, > > so it maybe should be valueization that does the canonicalization - > > but I think doing it > > elsewhere made operand order unreliable (we do end up with > > non-canonical order in > > the IL sometimes). > > > > So maybe you should amend the code in resimplifyN as well. > > Hmm, yeah, thanks for the heads up. Does this updated version look OK? > Tested as before. Yes - OK. Thanks, Richard. > Thanks, > Richard > > > gcc/ > * gimple-fold.c: Include internal-fn.h. > (fold_stmt_1): If a function maps to an internal one, use > first_commutative_argument to canonicalize the order of > commutative arguments. > * gimple-match-head.c (gimple_resimplify2, gimple_resimplify3) > (gimple_resimplify4, gimple_resimplify5): Extend commutativity > checks to functions. > > gcc/testsuite/ > * gcc.dg/fmax-fmin-1.c: New test. > --- > gcc/gimple-fold.c | 25 ++++++++++++-- > gcc/gimple-match-head.c | 52 ++++++++++++++++++++---------- > gcc/testsuite/gcc.dg/fmax-fmin-1.c | 18 +++++++++++ > 3 files changed, 75 insertions(+), 20 deletions(-) > create mode 100644 gcc/testsuite/gcc.dg/fmax-fmin-1.c > > diff --git a/gcc/gimple-fold.c b/gcc/gimple-fold.c > index 44fba12e150..1d8fd74f72c 100644 > --- a/gcc/gimple-fold.c > +++ b/gcc/gimple-fold.c > @@ -69,6 +69,7 @@ along with GCC; see the file COPYING3. If not see > #include "varasm.h" > #include "memmodel.h" > #include "optabs.h" > +#include "internal-fn.h" > > enum strlen_range_kind { > /* Compute the exact constant string length. */ > @@ -6109,18 +6110,36 @@ fold_stmt_1 (gimple_stmt_iterator *gsi, bool inplace, tree (*valueize) (tree)) > break; > case GIMPLE_CALL: > { > - for (i = 0; i < gimple_call_num_args (stmt); ++i) > + gcall *call = as_a<gcall *> (stmt); > + for (i = 0; i < gimple_call_num_args (call); ++i) > { > - tree *arg = gimple_call_arg_ptr (stmt, i); > + tree *arg = gimple_call_arg_ptr (call, i); > if (REFERENCE_CLASS_P (*arg) > && maybe_canonicalize_mem_ref_addr (arg)) > changed = true; > } > - tree *lhs = gimple_call_lhs_ptr (stmt); > + tree *lhs = gimple_call_lhs_ptr (call); > if (*lhs > && REFERENCE_CLASS_P (*lhs) > && maybe_canonicalize_mem_ref_addr (lhs)) > changed = true; > + if (*lhs) > + { > + combined_fn cfn = gimple_call_combined_fn (call); > + internal_fn ifn = associated_internal_fn (cfn, TREE_TYPE (*lhs)); > + int opno = first_commutative_argument (ifn); > + if (opno >= 0) > + { > + tree arg1 = gimple_call_arg (call, opno); > + tree arg2 = gimple_call_arg (call, opno + 1); > + if (tree_swap_operands_p (arg1, arg2)) > + { > + gimple_call_set_arg (call, opno, arg2); > + gimple_call_set_arg (call, opno + 1, arg1); > + changed = true; > + } > + } > + } > break; > } > case GIMPLE_ASM: > diff --git a/gcc/gimple-match-head.c b/gcc/gimple-match-head.c > index c481a625581..2d9364ca5de 100644 > --- a/gcc/gimple-match-head.c > +++ b/gcc/gimple-match-head.c > @@ -294,18 +294,16 @@ gimple_resimplify2 (gimple_seq *seq, gimple_match_op *res_op, > > /* Canonicalize operand order. */ > bool canonicalized = false; > - if (res_op->code.is_tree_code ()) > + bool is_comparison > + = (res_op->code.is_tree_code () > + && TREE_CODE_CLASS (tree_code (res_op->code)) == tcc_comparison); > + if ((is_comparison || commutative_binary_op_p (res_op->code, res_op->type)) > + && tree_swap_operands_p (res_op->ops[0], res_op->ops[1])) > { > - auto code = tree_code (res_op->code); > - if ((TREE_CODE_CLASS (code) == tcc_comparison > - || commutative_tree_code (code)) > - && tree_swap_operands_p (res_op->ops[0], res_op->ops[1])) > - { > - std::swap (res_op->ops[0], res_op->ops[1]); > - if (TREE_CODE_CLASS (code) == tcc_comparison) > - res_op->code = swap_tree_comparison (code); > - canonicalized = true; > - } > + std::swap (res_op->ops[0], res_op->ops[1]); > + if (is_comparison) > + res_op->code = swap_tree_comparison (tree_code (res_op->code)); > + canonicalized = true; > } > > /* Limit recursion, see gimple_resimplify1. */ > @@ -376,11 +374,11 @@ gimple_resimplify3 (gimple_seq *seq, gimple_match_op *res_op, > > /* Canonicalize operand order. */ > bool canonicalized = false; > - if (res_op->code.is_tree_code () > - && commutative_ternary_tree_code (tree_code (res_op->code)) > - && tree_swap_operands_p (res_op->ops[0], res_op->ops[1])) > + int argno = first_commutative_argument (res_op->code, res_op->type); > + if (argno >= 0 > + && tree_swap_operands_p (res_op->ops[argno], res_op->ops[argno + 1])) > { > - std::swap (res_op->ops[0], res_op->ops[1]); > + std::swap (res_op->ops[argno], res_op->ops[argno + 1]); > canonicalized = true; > } > > @@ -424,6 +422,16 @@ gimple_resimplify4 (gimple_seq *seq, gimple_match_op *res_op, > { > /* No constant folding is defined for four-operand functions. */ > > + /* Canonicalize operand order. */ > + bool canonicalized = false; > + int argno = first_commutative_argument (res_op->code, res_op->type); > + if (argno >= 0 > + && tree_swap_operands_p (res_op->ops[argno], res_op->ops[argno + 1])) > + { > + std::swap (res_op->ops[argno], res_op->ops[argno + 1]); > + canonicalized = true; > + } > + > /* Limit recursion, see gimple_resimplify1. */ > static unsigned depth; > if (depth > 10) > @@ -450,7 +458,7 @@ gimple_resimplify4 (gimple_seq *seq, gimple_match_op *res_op, > if (maybe_resimplify_conditional_op (seq, res_op, valueize)) > return true; > > - return false; > + return canonicalized; > } > > /* Helper that matches and simplifies the toplevel result from > @@ -465,6 +473,16 @@ gimple_resimplify5 (gimple_seq *seq, gimple_match_op *res_op, > { > /* No constant folding is defined for five-operand functions. */ > > + /* Canonicalize operand order. */ > + bool canonicalized = false; > + int argno = first_commutative_argument (res_op->code, res_op->type); > + if (argno >= 0 > + && tree_swap_operands_p (res_op->ops[argno], res_op->ops[argno + 1])) > + { > + std::swap (res_op->ops[argno], res_op->ops[argno + 1]); > + canonicalized = true; > + } > + > gimple_match_op res_op2 (*res_op); > if (gimple_simplify (&res_op2, seq, valueize, > res_op->code, res_op->type, > @@ -478,7 +496,7 @@ gimple_resimplify5 (gimple_seq *seq, gimple_match_op *res_op, > if (maybe_resimplify_conditional_op (seq, res_op, valueize)) > return true; > > - return false; > + return canonicalized; > } > > /* Match and simplify the toplevel valueized operation THIS. > diff --git a/gcc/testsuite/gcc.dg/fmax-fmin-1.c b/gcc/testsuite/gcc.dg/fmax-fmin-1.c > new file mode 100644 > index 00000000000..e7e0518d8bb > --- /dev/null > +++ b/gcc/testsuite/gcc.dg/fmax-fmin-1.c > @@ -0,0 +1,18 @@ > +/* { dg-options "-O -fdump-tree-optimized" } */ > + > +void > +f1 (double *res, double x, double y) > +{ > + res[0] = __builtin_fmax (x, y); > + res[1] = __builtin_fmax (y, x); > +} > + > +void > +f2 (double *res, double x, double y) > +{ > + res[0] = __builtin_fmin (x, y); > + res[1] = __builtin_fmin (y, x); > +} > + > +/* { dg-final { scan-tree-dump-times {__builtin_fmax} 1 "optimized" } } */ > +/* { dg-final { scan-tree-dump-times {__builtin_fmin} 1 "optimized" } } */ > -- > 2.25.1 > ^ permalink raw reply [flat|nested] 4+ messages in thread
end of thread, other threads:[~2021-11-30 7:40 UTC | newest] Thread overview: 4+ messages (download: mbox.gz / follow: Atom feed) -- links below jump to the message on this page -- 2021-11-10 12:48 [PATCH 1/4] Canonicalize argument order for commutative functions Richard Sandiford 2021-11-11 10:57 ` Richard Biener 2021-11-29 15:40 ` Richard Sandiford 2021-11-30 7:40 ` Richard Biener
This is a public inbox, see mirroring instructions for how to clone and mirror all data and code used for this inbox; as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).