Line data Source code
1 : /* A representation of vector permutation indices.
2 : Copyright (C) 2017-2026 Free Software Foundation, Inc.
3 :
4 : This file is part of GCC.
5 :
6 : GCC is free software; you can redistribute it and/or modify it under
7 : the terms of the GNU General Public License as published by the Free
8 : Software Foundation; either version 3, or (at your option) any later
9 : version.
10 :
11 : GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12 : WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 : FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 : for more details.
15 :
16 : You should have received a copy of the GNU General Public License
17 : along with GCC; see the file COPYING3. If not see
18 : <http://www.gnu.org/licenses/>. */
19 :
20 : #ifndef GCC_VEC_PERN_INDICES_H
21 : #define GCC_VEC_PERN_INDICES_H 1
22 :
23 : #include "int-vector-builder.h"
24 :
25 : /* A vector_builder for building constant permutation vectors.
26 : The elements do not need to be clamped to a particular range
27 : of input elements. */
28 : typedef int_vector_builder<poly_int64> vec_perm_builder;
29 :
30 : /* This class represents a constant permutation vector, such as that used
31 : as the final operand to a VEC_PERM_EXPR.
32 :
33 : Permutation vectors select indices modulo the number of input elements,
34 : and the class canonicalizes each permutation vector for a particular
35 : number of input vectors and for a particular number of elements per
36 : input. For example, the gimple statements:
37 :
38 : _1 = VEC_PERM_EXPR <a, a, { 0, 2, 4, 6, 0, 2, 4, 6 }>;
39 : _2 = VEC_PERM_EXPR <a, a, { 0, 2, 4, 6, 8, 10, 12, 14 }>;
40 : _3 = VEC_PERM_EXPR <a, a, { 0, 2, 20, 22, 24, 2, 4, 14 }>;
41 :
42 : effectively have only a single vector input "a". If "a" has 8
43 : elements, the indices select elements modulo 8, which makes all three
44 : VEC_PERM_EXPRs equivalent. The canonical form is for the indices to be
45 : in the range [0, number of input elements - 1], so the class treats the
46 : second and third permutation vectors as though they had been the first.
47 :
48 : The class copes with cases in which the input and output vectors have
49 : different numbers of elements. */
50 4370262 : class vec_perm_indices
51 : {
52 : typedef poly_int64 element_type;
53 :
54 : public:
55 : vec_perm_indices ();
56 : vec_perm_indices (const vec_perm_builder &, unsigned int, poly_uint64);
57 :
58 724978 : void new_vector (const vec_perm_builder &b, unsigned int ni, poly_uint64 ne)
59 : {
60 724978 : new_vector (b, ni, false, false, ne);
61 : }
62 : void new_vector (const vec_perm_builder &, unsigned int, bool, bool,
63 : poly_uint64);
64 : void new_expanded_vector (const vec_perm_indices &, unsigned int);
65 : bool new_shrunk_vector (const vec_perm_indices &, unsigned int);
66 : void rotate_inputs (int delta);
67 :
68 : /* Return the underlying vector encoding. */
69 : const vec_perm_builder &encoding () const { return m_encoding; }
70 :
71 : /* Return the number of output elements. This is called length ()
72 : so that we present a more vec-like interface. */
73 2269751 : poly_uint64 length () const { return m_encoding.full_nelts (); }
74 :
75 : /* Return the number of input vectors being permuted. */
76 18151 : unsigned int ninputs () const { return m_ninputs; }
77 :
78 : /* Return whether the input N is known bitwise zero. */
79 45836 : bool input_bitwise_zero_p (unsigned n) const
80 : {
81 22951 : return (n == 0 ? m_input0_bitwise_zero_p
82 22885 : : (n == 1 ? m_input1_bitwise_zero_p : false));
83 : }
84 :
85 : /* Return the number of elements in each input vector. */
86 1185129 : poly_uint64 nelts_per_input () const { return m_nelts_per_input; }
87 :
88 : /* Return the total number of input elements. */
89 5956032 : poly_uint64 input_nelts () const { return m_ninputs * m_nelts_per_input; }
90 :
91 : element_type clamp (element_type) const;
92 : element_type operator[] (unsigned int i) const;
93 : bool series_p (unsigned int, unsigned int, element_type, element_type) const;
94 : bool all_in_range_p (element_type, element_type) const;
95 : bool all_from_input_p (unsigned int) const;
96 :
97 : private:
98 : vec_perm_indices (const vec_perm_indices &);
99 :
100 : vec_perm_builder m_encoding;
101 : unsigned int m_ninputs;
102 : bool m_input0_bitwise_zero_p;
103 : bool m_input1_bitwise_zero_p;
104 : poly_uint64 m_nelts_per_input;
105 : };
106 :
107 : bool tree_to_vec_perm_builder (vec_perm_builder *, tree);
108 : bool tree_to_vec_perm_indices (vec_perm_indices *, tree, tree, tree);
109 : tree vec_perm_indices_to_tree (tree, const vec_perm_indices &);
110 : rtx vec_perm_indices_to_rtx (machine_mode, const vec_perm_indices &);
111 :
112 : inline
113 1448875 : vec_perm_indices::vec_perm_indices ()
114 1448875 : : m_ninputs (0),
115 1448875 : m_input0_bitwise_zero_p (false),
116 1448875 : m_input1_bitwise_zero_p (false),
117 1448875 : m_nelts_per_input (0)
118 : {
119 : }
120 :
121 : /* Construct a permutation vector that selects between NINPUTS vector
122 : inputs that have NELTS_PER_INPUT elements each. Take the elements of
123 : the new vector from ELEMENTS, clamping each one to be in range. */
124 :
125 : inline
126 2953679 : vec_perm_indices::vec_perm_indices (const vec_perm_builder &elements,
127 : unsigned int ninputs,
128 2953679 : poly_uint64 nelts_per_input)
129 : {
130 2953679 : new_vector (elements, ninputs, false, false, nelts_per_input);
131 2953679 : }
132 :
133 : /* Return the canonical value for permutation vector element ELT,
134 : taking into account the current number of input elements. */
135 :
136 : inline vec_perm_indices::element_type
137 52821204 : vec_perm_indices::clamp (element_type elt) const
138 : {
139 45679896 : element_type limit = input_nelts (), elem_within_input;
140 52821204 : HOST_WIDE_INT input;
141 52821204 : if (!can_div_trunc_p (elt, limit, &input, &elem_within_input))
142 : return elt;
143 :
144 : /* Treat negative elements as counting from the end. This only matters
145 : if the vector size is not a power of 2. */
146 52821204 : if (known_lt (elem_within_input, 0))
147 406643 : return elem_within_input + limit;
148 :
149 : return elem_within_input;
150 : }
151 :
152 : /* Return the value of vector element I, which might or might not be
153 : explicitly encoded. */
154 :
155 : inline vec_perm_indices::element_type
156 12695177 : vec_perm_indices::operator[] (unsigned int i) const
157 : {
158 12695177 : return clamp (m_encoding.elt (i));
159 : }
160 :
161 : /* Return true if the permutation vector only selects elements from
162 : input I. */
163 :
164 : inline bool
165 2395425 : vec_perm_indices::all_from_input_p (unsigned int i) const
166 : {
167 2395425 : return all_in_range_p (i * m_nelts_per_input, m_nelts_per_input);
168 : }
169 :
170 : #endif
|
