From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: by sourceware.org (Postfix, from userid 1666) id D3B2F380D708; Fri, 7 Jul 2023 11:57:45 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org D3B2F380D708 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gcc.gnu.org; s=default; t=1688731066; bh=8VqqyXg9EKFfblsCGSqhqFjt+s4LIS59proyMrgwq9o=; h=From:To:Subject:Date:From; b=SPH/dKAOPzZ523vGevejFKqMQcq3RwqyS+iaDZo6ZAUUgAup61zWaklXDD+ZDMksw 9VM/gQqqKtgTvM/FJHgXa8y5tLds85HwdDZQzx9NpA1ulrRKwUO6VITrAqmrj/WtHH I76wC8smBT28US8a53U5m7Huuf2wzjo4b+UNGyDA= MIME-Version: 1.0 Content-Transfer-Encoding: 7bit Content-Type: text/plain; charset="utf-8" From: Richard Biener To: gcc-cvs@gcc.gnu.org Subject: [gcc r13-7543] tree-optimization/110381 - preserve SLP permutation with in-order reductions X-Act-Checkin: gcc X-Git-Author: Richard Biener X-Git-Refname: refs/heads/releases/gcc-13 X-Git-Oldrev: 857d763ed1be933c74cbc7489282aea0e2c778fb X-Git-Newrev: 32c7f05f8bc6d45dee374fe22be3f0e19836278a Message-Id: <20230707115746.D3B2F380D708@sourceware.org> Date: Fri, 7 Jul 2023 11:57:45 +0000 (GMT) List-Id: https://gcc.gnu.org/g:32c7f05f8bc6d45dee374fe22be3f0e19836278a commit r13-7543-g32c7f05f8bc6d45dee374fe22be3f0e19836278a Author: Richard Biener Date: Mon Jun 26 12:51:37 2023 +0200 tree-optimization/110381 - preserve SLP permutation with in-order reductions The following fixes a bug that manifests itself during fold-left reduction transform in picking not the last scalar def to replace and thus double-counting some elements. But the underlying issue is that we merge a load permutation into the in-order reduction which is of course wrong. Now, reduction analysis has not yet been performend when optimizing permutations so we have to resort to check that ourselves. PR tree-optimization/110381 * tree-vect-slp.cc (vect_optimize_slp_pass::start_choosing_layouts): Materialize permutes before fold-left reductions. * gcc.dg/vect/pr110381.c: New testcase. (cherry picked from commit 53d6f57c1b20c6da52aefce737fb7d5263686ba3) Diff: --- gcc/testsuite/gcc.dg/vect/pr110381.c | 45 ++++++++++++++++++++++++++++++++++++ gcc/tree-vect-slp.cc | 18 +++++++++++++-- 2 files changed, 61 insertions(+), 2 deletions(-) diff --git a/gcc/testsuite/gcc.dg/vect/pr110381.c b/gcc/testsuite/gcc.dg/vect/pr110381.c new file mode 100644 index 00000000000..ee78666d2e8 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/pr110381.c @@ -0,0 +1,45 @@ +/* { dg-do run } */ +/* { dg-require-effective-target vect_float_strict } */ + +#include "tree-vect.h" + +struct FOO { + double a; + double b; + double c; +}; + +double __attribute__((noipa)) +sum_8_foos(const struct FOO* foos) +{ + double sum = 0; + + for (int i = 0; i < 8; ++i) + { + struct FOO foo = foos[i]; + + /* Need to use an in-order reduction here, preserving + the load permutation. */ + sum += foo.a; + sum += foo.c; + sum += foo.b; + } + + return sum; +} + +int main() +{ + struct FOO foos[8]; + + check_vect (); + + __builtin_memset (foos, 0, sizeof (foos)); + foos[0].a = __DBL_MAX__; + foos[0].b = 5; + foos[0].c = -__DBL_MAX__; + + if (sum_8_foos (foos) != 5) + __builtin_abort (); + return 0; +} diff --git a/gcc/tree-vect-slp.cc b/gcc/tree-vect-slp.cc index d73deaecce0..4b948c04499 100644 --- a/gcc/tree-vect-slp.cc +++ b/gcc/tree-vect-slp.cc @@ -4670,14 +4670,28 @@ vect_optimize_slp_pass::start_choosing_layouts () m_partition_layout_costs.safe_grow_cleared (m_partitions.length () * m_perms.length ()); - /* We have to mark outgoing permutations facing non-reduction graph - entries that are not represented as to be materialized. */ + /* We have to mark outgoing permutations facing non-associating-reduction + graph entries that are not represented as to be materialized. + slp_inst_kind_bb_reduc currently only covers associatable reductions. */ for (slp_instance instance : m_vinfo->slp_instances) if (SLP_INSTANCE_KIND (instance) == slp_inst_kind_ctor) { unsigned int node_i = SLP_INSTANCE_TREE (instance)->vertex; m_partitions[m_vertices[node_i].partition].layout = 0; } + else if (SLP_INSTANCE_KIND (instance) == slp_inst_kind_reduc_chain) + { + stmt_vec_info stmt_info + = SLP_TREE_REPRESENTATIVE (SLP_INSTANCE_TREE (instance)); + stmt_vec_info reduc_info = info_for_reduction (m_vinfo, stmt_info); + if (needs_fold_left_reduction_p (TREE_TYPE + (gimple_get_lhs (stmt_info->stmt)), + STMT_VINFO_REDUC_CODE (reduc_info))) + { + unsigned int node_i = SLP_INSTANCE_TREE (instance)->vertex; + m_partitions[m_vertices[node_i].partition].layout = 0; + } + } /* Check which layouts each node and partition can handle. Calculate the weights associated with inserting layout changes on edges. */