Daily bump.
[official-gcc.git] / gcc / internal-fn.h
blob19d0f849a5adc5d7f246d15b629e91eb8d4cbc24
1 /* Internal functions.
2 Copyright (C) 2011-2021 Free Software Foundation, Inc.
4 This file is part of GCC.
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.
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.
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/>. */
20 #ifndef GCC_INTERNAL_FN_H
21 #define GCC_INTERNAL_FN_H
23 /* INTEGER_CST values for IFN_UNIQUE function arg-0.
25 UNSPEC: Undifferentiated UNIQUE.
27 FORK and JOIN mark the points at which OpenACC partitioned
28 execution is entered or exited.
29 DEP_VAR = UNIQUE ({FORK,JOIN}, DEP_VAR, AXIS)
31 HEAD_MARK and TAIL_MARK are used to demark the sequence entering
32 or leaving partitioned execution.
33 DEP_VAR = UNIQUE ({HEAD,TAIL}_MARK, REMAINING_MARKS, ...PRIMARY_FLAGS)
35 The PRIMARY_FLAGS only occur on the first HEAD_MARK of a sequence.
37 PRIVATE captures variables to be made private at the surrounding parallelism
38 level. */
39 #define IFN_UNIQUE_CODES \
40 DEF(UNSPEC), \
41 DEF(OACC_FORK), DEF(OACC_JOIN), \
42 DEF(OACC_HEAD_MARK), DEF(OACC_TAIL_MARK), \
43 DEF(OACC_PRIVATE)
45 enum ifn_unique_kind {
46 #define DEF(X) IFN_UNIQUE_##X
47 IFN_UNIQUE_CODES
48 #undef DEF
51 /* INTEGER_CST values for IFN_GOACC_LOOP arg-0. Allows the precise
52 stepping of the compute geometry over the loop iterations to be
53 deferred until it is known which compiler is generating the code.
54 The action is encoded in a constant first argument.
56 CHUNK_MAX = LOOP (CODE_CHUNKS, DIR, RANGE, STEP, CHUNK_SIZE, MASK)
57 STEP = LOOP (CODE_STEP, DIR, RANGE, STEP, CHUNK_SIZE, MASK)
58 OFFSET = LOOP (CODE_OFFSET, DIR, RANGE, STEP, CHUNK_SIZE, MASK, CHUNK_NO)
59 BOUND = LOOP (CODE_BOUND, DIR, RANGE, STEP, CHUNK_SIZE, MASK, OFFSET)
61 DIR - +1 for up loop, -1 for down loop
62 RANGE - Range of loop (END - BASE)
63 STEP - iteration step size
64 CHUNKING - size of chunking, (constant zero for no chunking)
65 CHUNK_NO - chunk number
66 MASK - partitioning mask. */
68 #define IFN_GOACC_LOOP_CODES \
69 DEF(CHUNKS), DEF(STEP), DEF(OFFSET), DEF(BOUND)
70 enum ifn_goacc_loop_kind {
71 #define DEF(X) IFN_GOACC_LOOP_##X
72 IFN_GOACC_LOOP_CODES
73 #undef DEF
76 /* The GOACC_REDUCTION function defines a generic interface to support
77 gang, worker and vector reductions. All calls are of the following
78 form:
80 V = REDUCTION (CODE, REF_TO_RES, LOCAL_VAR, LEVEL, OP, OFFSET)
82 REF_TO_RES - is a reference to the original reduction varl, may be NULL
83 LOCAL_VAR is the intermediate reduction variable
84 LEVEL corresponds to the GOMP_DIM of the reduction
85 OP is the tree code of the reduction operation
86 OFFSET may be used as an offset into a reduction array for the
87 reductions occuring at this level.
88 In general the return value is LOCAL_VAR, which creates a data
89 dependency between calls operating on the same reduction. */
91 #define IFN_GOACC_REDUCTION_CODES \
92 DEF(SETUP), DEF(INIT), DEF(FINI), DEF(TEARDOWN)
93 enum ifn_goacc_reduction_kind {
94 #define DEF(X) IFN_GOACC_REDUCTION_##X
95 IFN_GOACC_REDUCTION_CODES
96 #undef DEF
99 /* Initialize internal function tables. */
101 extern void init_internal_fns ();
103 /* Return the name of internal function FN. The name is only meaningful
104 for dumps; it has no linkage. */
106 extern const char *const internal_fn_name_array[];
108 static inline const char *
109 internal_fn_name (enum internal_fn fn)
111 return internal_fn_name_array[(int) fn];
114 extern internal_fn lookup_internal_fn (const char *);
116 /* Return the ECF_* flags for function FN. */
118 extern const int internal_fn_flags_array[];
120 static inline int
121 internal_fn_flags (enum internal_fn fn)
123 return internal_fn_flags_array[(int) fn];
126 /* Return fnspec for function FN. */
128 extern GTY(()) const_tree internal_fn_fnspec_array[IFN_LAST + 1];
130 static inline const_tree
131 internal_fn_fnspec (enum internal_fn fn)
133 return internal_fn_fnspec_array[(int) fn];
136 /* Describes an internal function that maps directly to an optab. */
137 struct direct_internal_fn_info
139 /* optabs can be parameterized by one or two modes. These fields describe
140 how to select those modes from the types of the return value and
141 arguments. A value of -1 says that the mode is determined by the
142 return type while a value N >= 0 says that the mode is determined by
143 the type of argument N. A value of -2 says that this internal
144 function isn't directly mapped to an optab. */
145 signed int type0 : 8;
146 signed int type1 : 8;
147 /* True if the function is pointwise, so that it can be vectorized by
148 converting the return type and all argument types to vectors of the
149 same number of elements. E.g. we can vectorize an IFN_SQRT on
150 floats as an IFN_SQRT on vectors of N floats.
152 This only needs 1 bit, but occupies the full 16 to ensure a nice
153 layout. */
154 unsigned int vectorizable : 16;
157 extern const direct_internal_fn_info direct_internal_fn_array[IFN_LAST + 1];
159 /* Return true if FN is mapped directly to an optab. */
161 inline bool
162 direct_internal_fn_p (internal_fn fn)
164 return direct_internal_fn_array[fn].type0 >= -1;
167 /* Return true if FN is a direct internal function that can be vectorized by
168 converting the return type and all argument types to vectors of the same
169 number of elements. E.g. we can vectorize an IFN_SQRT on floats as an
170 IFN_SQRT on vectors of N floats. */
172 inline bool
173 vectorizable_internal_fn_p (internal_fn fn)
175 return direct_internal_fn_array[fn].vectorizable;
178 /* Return optab information about internal function FN. Only meaningful
179 if direct_internal_fn_p (FN). */
181 inline const direct_internal_fn_info &
182 direct_internal_fn (internal_fn fn)
184 gcc_checking_assert (direct_internal_fn_p (fn));
185 return direct_internal_fn_array[fn];
188 extern tree_pair direct_internal_fn_types (internal_fn, tree, tree *);
189 extern tree_pair direct_internal_fn_types (internal_fn, gcall *);
190 extern bool direct_internal_fn_supported_p (internal_fn, tree_pair,
191 optimization_type);
192 extern bool direct_internal_fn_supported_p (internal_fn, tree,
193 optimization_type);
194 extern bool direct_internal_fn_supported_p (gcall *, optimization_type);
196 /* Return true if FN is supported for types TYPE0 and TYPE1 when the
197 optimization type is OPT_TYPE. The types are those associated with
198 the "type0" and "type1" fields of FN's direct_internal_fn_info
199 structure. */
201 inline bool
202 direct_internal_fn_supported_p (internal_fn fn, tree type0, tree type1,
203 optimization_type opt_type)
205 return direct_internal_fn_supported_p (fn, tree_pair (type0, type1),
206 opt_type);
209 extern int first_commutative_argument (internal_fn);
211 extern bool set_edom_supported_p (void);
213 extern internal_fn get_conditional_internal_fn (tree_code);
214 extern internal_fn get_conditional_internal_fn (internal_fn);
215 extern tree_code conditional_internal_fn_code (internal_fn);
216 extern internal_fn get_unconditional_internal_fn (internal_fn);
217 extern bool can_interpret_as_conditional_op_p (gimple *, tree *,
218 tree_code *, tree (&)[3],
219 tree *);
221 extern bool internal_load_fn_p (internal_fn);
222 extern bool internal_store_fn_p (internal_fn);
223 extern bool internal_gather_scatter_fn_p (internal_fn);
224 extern int internal_fn_mask_index (internal_fn);
225 extern int internal_fn_stored_value_index (internal_fn);
226 extern bool internal_gather_scatter_fn_supported_p (internal_fn, tree,
227 tree, tree, int);
228 extern bool internal_check_ptrs_fn_supported_p (internal_fn, tree,
229 poly_uint64, unsigned int);
231 extern void expand_addsub_overflow (location_t, tree_code, tree, tree, tree,
232 bool, bool, bool, bool, tree *);
233 extern void expand_internal_call (gcall *);
234 extern void expand_internal_call (internal_fn, gcall *);
235 extern void expand_PHI (internal_fn, gcall *);
236 extern void expand_SHUFFLEVECTOR (internal_fn, gcall *);
238 extern bool vectorized_internal_fn_supported_p (internal_fn, tree);
240 #endif