Line data Source code
1 : /* Internal functions.
2 : Copyright (C) 2011-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_INTERNAL_FN_H
21 : #define GCC_INTERNAL_FN_H
22 :
23 : #include "insn-codes.h"
24 : #include "insn-opinit.h"
25 :
26 :
27 : /* INTEGER_CST values for IFN_UNIQUE function arg-0.
28 :
29 : UNSPEC: Undifferentiated UNIQUE.
30 :
31 : FORK and JOIN mark the points at which OpenACC partitioned
32 : execution is entered or exited.
33 : DEP_VAR = UNIQUE ({FORK,JOIN}, DEP_VAR, AXIS)
34 :
35 : HEAD_MARK and TAIL_MARK are used to demark the sequence entering
36 : or leaving partitioned execution.
37 : DEP_VAR = UNIQUE ({HEAD,TAIL}_MARK, REMAINING_MARKS, ...PRIMARY_FLAGS)
38 :
39 : The PRIMARY_FLAGS only occur on the first HEAD_MARK of a sequence.
40 :
41 : PRIVATE captures variables to be made private at the surrounding parallelism
42 : level. */
43 : #define IFN_UNIQUE_CODES \
44 : DEF(UNSPEC), \
45 : DEF(OACC_FORK), DEF(OACC_JOIN), \
46 : DEF(OACC_HEAD_MARK), DEF(OACC_TAIL_MARK), \
47 : DEF(OACC_PRIVATE)
48 :
49 : enum ifn_unique_kind {
50 : #define DEF(X) IFN_UNIQUE_##X
51 : IFN_UNIQUE_CODES
52 : #undef DEF
53 : };
54 :
55 : /* INTEGER_CST values for IFN_GOACC_LOOP arg-0. Allows the precise
56 : stepping of the compute geometry over the loop iterations to be
57 : deferred until it is known which compiler is generating the code.
58 : The action is encoded in a constant first argument.
59 :
60 : CHUNK_MAX = LOOP (CODE_CHUNKS, DIR, RANGE, STEP, CHUNK_SIZE, MASK)
61 : STEP = LOOP (CODE_STEP, DIR, RANGE, STEP, CHUNK_SIZE, MASK)
62 : OFFSET = LOOP (CODE_OFFSET, DIR, RANGE, STEP, CHUNK_SIZE, MASK, CHUNK_NO)
63 : BOUND = LOOP (CODE_BOUND, DIR, RANGE, STEP, CHUNK_SIZE, MASK, OFFSET)
64 :
65 : DIR - +1 for up loop, -1 for down loop
66 : RANGE - Range of loop (END - BASE)
67 : STEP - iteration step size
68 : CHUNKING - size of chunking, (constant zero for no chunking)
69 : CHUNK_NO - chunk number
70 : MASK - partitioning mask. */
71 :
72 : #define IFN_GOACC_LOOP_CODES \
73 : DEF(CHUNKS), DEF(STEP), DEF(OFFSET), DEF(BOUND)
74 : enum ifn_goacc_loop_kind {
75 : #define DEF(X) IFN_GOACC_LOOP_##X
76 : IFN_GOACC_LOOP_CODES
77 : #undef DEF
78 : };
79 :
80 : /* The GOACC_REDUCTION function defines a generic interface to support
81 : gang, worker and vector reductions. All calls are of the following
82 : form:
83 :
84 : V = REDUCTION (CODE, REF_TO_RES, LOCAL_VAR, LEVEL, OP, OFFSET)
85 :
86 : REF_TO_RES - is a reference to the original reduction varl, may be NULL
87 : LOCAL_VAR is the intermediate reduction variable
88 : LEVEL corresponds to the GOMP_DIM of the reduction
89 : OP is the tree code of the reduction operation
90 : OFFSET may be used as an offset into a reduction array for the
91 : reductions occurring at this level.
92 : In general the return value is LOCAL_VAR, which creates a data
93 : dependency between calls operating on the same reduction. */
94 :
95 : #define IFN_GOACC_REDUCTION_CODES \
96 : DEF(SETUP), DEF(INIT), DEF(FINI), DEF(TEARDOWN)
97 : enum ifn_goacc_reduction_kind {
98 : #define DEF(X) IFN_GOACC_REDUCTION_##X
99 : IFN_GOACC_REDUCTION_CODES
100 : #undef DEF
101 : };
102 :
103 : /* Initialize internal function tables. */
104 :
105 : extern void init_internal_fns ();
106 :
107 : /* Return the name of internal function FN. The name is only meaningful
108 : for dumps; it has no linkage. */
109 :
110 : extern const char *const internal_fn_name_array[];
111 :
112 : inline const char *
113 42129750 : internal_fn_name (enum internal_fn fn)
114 : {
115 42129750 : return internal_fn_name_array[(int) fn];
116 : }
117 :
118 : extern internal_fn lookup_internal_fn (const char *);
119 : extern void lookup_hilo_internal_fn (internal_fn, internal_fn *, internal_fn *);
120 : extern void lookup_evenodd_internal_fn (internal_fn, internal_fn *,
121 : internal_fn *);
122 : extern optab direct_internal_fn_optab (internal_fn, tree_pair);
123 :
124 : /* Return the ECF_* flags for function FN. */
125 :
126 : extern const int internal_fn_flags_array[];
127 :
128 : inline int
129 125895302 : internal_fn_flags (enum internal_fn fn)
130 : {
131 125895302 : return internal_fn_flags_array[(int) fn];
132 : }
133 :
134 : /* Return fnspec for function FN. */
135 :
136 : extern GTY(()) const_tree internal_fn_fnspec_array[IFN_LAST + 1];
137 :
138 : inline const_tree
139 9895944 : internal_fn_fnspec (enum internal_fn fn)
140 : {
141 9895944 : return internal_fn_fnspec_array[(int) fn];
142 : }
143 :
144 : /* Describes an internal function that maps directly to an optab. */
145 : struct direct_internal_fn_info
146 : {
147 : /* optabs can be parameterized by one or two modes. These fields describe
148 : how to select those modes from the types of the return value and
149 : arguments. A value of -1 says that the mode is determined by the
150 : return type while a value N >= 0 says that the mode is determined by
151 : the type of argument N. A value of -2 says that this internal
152 : function isn't directly mapped to an optab. */
153 : signed int type0 : 8;
154 : signed int type1 : 8;
155 : /* True if the function is pointwise, so that it can be vectorized by
156 : converting the return type and all argument types to vectors of the
157 : same number of elements. E.g. we can vectorize an IFN_SQRT on
158 : floats as an IFN_SQRT on vectors of N floats.
159 :
160 : This only needs 1 bit, but occupies the full 8 to ensure a nice
161 : layout. */
162 : unsigned int vectorizable : 8;
163 : /* The minimum and maximum number of arguments of a call to the
164 : function. */
165 : unsigned int nargs_min : 4;
166 : unsigned int nargs_max : 4;
167 : };
168 :
169 : extern const direct_internal_fn_info direct_internal_fn_array[IFN_LAST + 1];
170 :
171 : /* Return true if FN is mapped directly to an optab. */
172 :
173 : inline bool
174 48321503 : direct_internal_fn_p (internal_fn fn)
175 : {
176 42297411 : return direct_internal_fn_array[fn].type0 >= -1;
177 : }
178 :
179 : /* Return true if FN is a direct internal function that can be vectorized by
180 : converting the return type and all argument types to vectors of the same
181 : number of elements. E.g. we can vectorize an IFN_SQRT on floats as an
182 : IFN_SQRT on vectors of N floats. */
183 :
184 : inline bool
185 40347 : vectorizable_internal_fn_p (internal_fn fn)
186 : {
187 40347 : return direct_internal_fn_array[fn].vectorizable;
188 : }
189 :
190 : /* Return optab information about internal function FN. Only meaningful
191 : if direct_internal_fn_p (FN). */
192 :
193 : inline const direct_internal_fn_info &
194 6024092 : direct_internal_fn (internal_fn fn)
195 : {
196 6024092 : gcc_checking_assert (direct_internal_fn_p (fn));
197 6024092 : return direct_internal_fn_array[fn];
198 : }
199 :
200 : /* Return true if a call to FN can have NARGS arguments. FN must satisfy
201 : direct_internal_fn_p. */
202 :
203 : inline bool
204 77458 : direct_internal_fn_nargs_ok_p (internal_fn fn, unsigned int nargs)
205 : {
206 77458 : const direct_internal_fn_info &info = direct_internal_fn (fn);
207 77458 : return nargs >= info.nargs_min && nargs <= info.nargs_max;
208 : }
209 :
210 : extern tree_pair direct_internal_fn_types (internal_fn, tree, tree *);
211 : extern tree_pair direct_internal_fn_types (internal_fn, gcall *);
212 : extern bool direct_internal_fn_supported_p (internal_fn, tree_pair,
213 : optimization_type);
214 : extern bool direct_internal_fn_supported_p (internal_fn, tree,
215 : optimization_type);
216 : extern bool direct_internal_fn_supported_p (gcall *, optimization_type);
217 :
218 : /* Return true if FN is supported for types TYPE0 and TYPE1 when the
219 : optimization type is OPT_TYPE. The types are those associated with
220 : the "type0" and "type1" fields of FN's direct_internal_fn_info
221 : structure. */
222 :
223 : inline bool
224 113306 : direct_internal_fn_supported_p (internal_fn fn, tree type0, tree type1,
225 : optimization_type opt_type)
226 : {
227 113306 : return direct_internal_fn_supported_p (fn, tree_pair (type0, type1),
228 : opt_type);
229 : }
230 :
231 : extern bool commutative_binary_fn_p (internal_fn);
232 : extern bool commutative_ternary_fn_p (internal_fn);
233 : extern int first_commutative_argument (internal_fn);
234 : extern bool associative_binary_fn_p (internal_fn);
235 : extern bool widening_fn_p (code_helper);
236 : extern bool widening_evenodd_fn_p (code_helper);
237 :
238 : extern bool set_edom_supported_p (void);
239 : extern bool check_internal_fn_args (location_t, internal_fn, unsigned int,
240 : const tree *);
241 :
242 : extern internal_fn get_conditional_internal_fn (tree_code);
243 : extern internal_fn get_conditional_internal_fn (internal_fn);
244 : extern internal_fn get_len_internal_fn (internal_fn);
245 : extern internal_fn get_conditional_len_internal_fn (tree_code);
246 : extern tree_code conditional_internal_fn_code (internal_fn);
247 : extern internal_fn get_unconditional_internal_fn (internal_fn);
248 : extern bool can_interpret_as_conditional_op_p (gimple *, tree *,
249 : tree_code *, tree (&)[3],
250 : tree *, tree *, tree *);
251 :
252 : extern bool internal_load_fn_p (internal_fn);
253 : extern bool internal_store_fn_p (internal_fn);
254 : extern bool internal_gather_scatter_fn_p (internal_fn);
255 : extern int internal_fn_mask_index (internal_fn);
256 : extern int internal_fn_len_index (internal_fn);
257 : extern int internal_fn_else_index (internal_fn);
258 : extern int internal_fn_stored_value_index (internal_fn);
259 : extern int internal_fn_offset_index (internal_fn fn);
260 : extern int internal_fn_scale_index (internal_fn fn);
261 : extern int internal_fn_alias_ptr_index (internal_fn fn);
262 : extern bool internal_gather_scatter_fn_supported_p (internal_fn, tree,
263 : tree, tree, int,
264 : vec<int> * = nullptr);
265 : extern bool internal_strided_fn_supported_p (internal_fn, tree,
266 : vec<int> * = nullptr);
267 : extern bool internal_check_ptrs_fn_supported_p (internal_fn, tree,
268 : poly_uint64, unsigned int);
269 :
270 : /* Integer constants representing which else value is supported for masked load
271 : functions. */
272 : #define MASK_LOAD_ELSE_ZERO -1
273 : #define MASK_LOAD_ELSE_M1 -2
274 : #define MASK_LOAD_ELSE_UNDEFINED -3
275 :
276 : extern void get_supported_else_vals (enum insn_code, unsigned, vec<int> &);
277 : extern bool supported_else_val_p (enum insn_code, unsigned, int);
278 :
279 : #define VECT_PARTIAL_BIAS_UNSUPPORTED 127
280 :
281 : extern signed char internal_len_load_store_bias (internal_fn ifn,
282 : machine_mode);
283 :
284 : extern void expand_addsub_overflow (location_t, tree_code, tree, tree, tree,
285 : bool, bool, bool, bool, tree *);
286 : extern void expand_internal_call (gcall *);
287 : extern void expand_internal_call (internal_fn, gcall *);
288 : extern void expand_PHI (internal_fn, gcall *);
289 : extern void expand_SHUFFLEVECTOR (internal_fn, gcall *);
290 : extern void expand_SPACESHIP (internal_fn, gcall *);
291 : extern void expand_TRAP (internal_fn, gcall *);
292 : extern void expand_ASSUME (internal_fn, gcall *);
293 : extern void expand_MASK_CALL (internal_fn, gcall *);
294 : extern void expand_VARYING (internal_fn, gcall *);
295 : extern void expand_MULBITINT (internal_fn, gcall *);
296 : extern void expand_DIVMODBITINT (internal_fn, gcall *);
297 : extern void expand_FLOATTOBITINT (internal_fn, gcall *);
298 : extern void expand_BITINTTOFLOAT (internal_fn, gcall *);
299 : extern void expand_CLRSB (internal_fn, gcall *);
300 : extern void expand_CLZ (internal_fn, gcall *);
301 : extern void expand_CTZ (internal_fn, gcall *);
302 : extern void expand_FFS (internal_fn, gcall *);
303 : extern void expand_PARITY (internal_fn, gcall *);
304 : extern void expand_POPCOUNT (internal_fn, gcall *);
305 : extern void expand_BSWAP (internal_fn, gcall *);
306 : extern void expand_BITREVERSE (internal_fn, gcall *);
307 : extern void expand_CLMUL (internal_fn, gcall *);
308 : extern void expand_CLMUL_WIDEN (internal_fn, gcall *);
309 :
310 : extern bool vectorized_internal_fn_supported_p (internal_fn, tree);
311 :
312 : enum {
313 : ATOMIC_OP_FETCH_CMP_0_EQ = 0,
314 : ATOMIC_OP_FETCH_CMP_0_NE = 1,
315 : ATOMIC_OP_FETCH_CMP_0_LT = 2,
316 : ATOMIC_OP_FETCH_CMP_0_LE = 3,
317 : ATOMIC_OP_FETCH_CMP_0_GT = 4,
318 : ATOMIC_OP_FETCH_CMP_0_GE = 5
319 : };
320 :
321 : #endif
|