From d34457c138d06e989c871e7b295c06a8b9873703 Mon Sep 17 00:00:00 2001 From: Richard Sandiford Date: Wed, 3 Jan 2018 07:17:18 +0000 Subject: [PATCH] poly_int: folding BIT_FIELD_REFs on vectors This patch makes the: (BIT_FIELD_REF CONSTRUCTOR@0 @1 @2) folder cope with polynomial numbers of elements. 2018-01-03 Richard Sandiford Alan Hayward David Sherwood gcc/ * match.pd: Cope with polynomial numbers of vector elements. Co-Authored-By: Alan Hayward Co-Authored-By: David Sherwood From-SVN: r256147 --- gcc/ChangeLog | 6 ++++++ gcc/match.pd | 47 ++++++++++++++++++++++------------------------- 2 files changed, 28 insertions(+), 25 deletions(-) diff --git a/gcc/ChangeLog b/gcc/ChangeLog index 28998830858..ae13a2f68d3 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,3 +1,9 @@ +2018-01-03 Richard Sandiford + Alan Hayward + David Sherwood + + * match.pd: Cope with polynomial numbers of vector elements. + 2018-01-03 Richard Sandiford Alan Hayward David Sherwood diff --git a/gcc/match.pd b/gcc/match.pd index 06af2a72213..a2a1b8f4c95 100644 --- a/gcc/match.pd +++ b/gcc/match.pd @@ -4530,46 +4530,43 @@ DEFINE_INT_AND_FLOAT_ROUND_FN (RINT) idx = idx / width; n = n / width; /* Constructor elements can be subvectors. */ - unsigned HOST_WIDE_INT k = 1; + poly_uint64 k = 1; if (CONSTRUCTOR_NELTS (ctor) != 0) { tree cons_elem = TREE_TYPE (CONSTRUCTOR_ELT (ctor, 0)->value); if (TREE_CODE (cons_elem) == VECTOR_TYPE) k = TYPE_VECTOR_SUBPARTS (cons_elem); } + unsigned HOST_WIDE_INT elt, count, const_k; } (switch /* We keep an exact subset of the constructor elements. */ - (if ((idx % k) == 0 && (n % k) == 0) + (if (multiple_p (idx, k, &elt) && multiple_p (n, k, &count)) (if (CONSTRUCTOR_NELTS (ctor) == 0) { build_constructor (type, NULL); } - (with + (if (count == 1) + (if (elt < CONSTRUCTOR_NELTS (ctor)) + { CONSTRUCTOR_ELT (ctor, elt)->value; } + { build_zero_cst (type); }) { - idx /= k; - n /= k; - } - (if (n == 1) - (if (idx < CONSTRUCTOR_NELTS (ctor)) - { CONSTRUCTOR_ELT (ctor, idx)->value; } - { build_zero_cst (type); }) - { - vec *vals; - vec_alloc (vals, n); - for (unsigned i = 0; - i < n && idx + i < CONSTRUCTOR_NELTS (ctor); ++i) - CONSTRUCTOR_APPEND_ELT (vals, NULL_TREE, - CONSTRUCTOR_ELT (ctor, idx + i)->value); - build_constructor (type, vals); - })))) + vec *vals; + vec_alloc (vals, count); + for (unsigned i = 0; + i < count && elt + i < CONSTRUCTOR_NELTS (ctor); ++i) + CONSTRUCTOR_APPEND_ELT (vals, NULL_TREE, + CONSTRUCTOR_ELT (ctor, elt + i)->value); + build_constructor (type, vals); + }))) /* The bitfield references a single constructor element. */ - (if (idx + n <= (idx / k + 1) * k) + (if (k.is_constant (&const_k) + && idx + n <= (idx / const_k + 1) * const_k) (switch - (if (CONSTRUCTOR_NELTS (ctor) <= idx / k) + (if (CONSTRUCTOR_NELTS (ctor) <= idx / const_k) { build_zero_cst (type); }) - (if (n == k) - { CONSTRUCTOR_ELT (ctor, idx / k)->value; }) - (BIT_FIELD_REF { CONSTRUCTOR_ELT (ctor, idx / k)->value; } - @1 { bitsize_int ((idx % k) * width); }))))))))) + (if (n == const_k) + { CONSTRUCTOR_ELT (ctor, idx / const_k)->value; }) + (BIT_FIELD_REF { CONSTRUCTOR_ELT (ctor, idx / const_k)->value; } + @1 { bitsize_int ((idx % const_k) * width); }))))))))) /* Simplify a bit extraction from a bit insertion for the cases with the inserted element fully covering the extraction or the insertion -- 2.30.2