1/* Tree-based target query functions relating to optabs
2 Copyright (C) 1987-2017 Free Software Foundation, Inc.
3
4This file is part of GCC.
5
6GCC is free software; you can redistribute it and/or modify it under
7the terms of the GNU General Public License as published by the Free
8Software Foundation; either version 3, or (at your option) any later
9version.
10
11GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12WARRANTY; without even the implied warranty of MERCHANTABILITY or
13FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14for more details.
15
16You should have received a copy of the GNU General Public License
17along with GCC; see the file COPYING3. If not see
18<http://www.gnu.org/licenses/>. */
19
20
21#include "config.h"
22#include "system.h"
23#include "coretypes.h"
24#include "target.h"
25#include "insn-codes.h"
26#include "tree.h"
27#include "optabs-tree.h"
28#include "stor-layout.h"
29
30/* Return the optab used for computing the operation given by the tree code,
31 CODE and the tree EXP. This function is not always usable (for example, it
32 cannot give complete results for multiplication or division) but probably
33 ought to be relied on more widely throughout the expander. */
34optab
35optab_for_tree_code (enum tree_code code, const_tree type,
36 enum optab_subtype subtype)
37{
38 bool trapv;
39 switch (code)
40 {
41 case BIT_AND_EXPR:
42 return and_optab;
43
44 case BIT_IOR_EXPR:
45 return ior_optab;
46
47 case BIT_NOT_EXPR:
48 return one_cmpl_optab;
49
50 case BIT_XOR_EXPR:
51 return xor_optab;
52
53 case MULT_HIGHPART_EXPR:
54 return TYPE_UNSIGNED (type) ? umul_highpart_optab : smul_highpart_optab;
55
56 case TRUNC_MOD_EXPR:
57 case CEIL_MOD_EXPR:
58 case FLOOR_MOD_EXPR:
59 case ROUND_MOD_EXPR:
60 return TYPE_UNSIGNED (type) ? umod_optab : smod_optab;
61
62 case RDIV_EXPR:
63 case TRUNC_DIV_EXPR:
64 case CEIL_DIV_EXPR:
65 case FLOOR_DIV_EXPR:
66 case ROUND_DIV_EXPR:
67 case EXACT_DIV_EXPR:
68 if (TYPE_SATURATING (type))
69 return TYPE_UNSIGNED (type) ? usdiv_optab : ssdiv_optab;
70 return TYPE_UNSIGNED (type) ? udiv_optab : sdiv_optab;
71
72 case LSHIFT_EXPR:
73 if (TREE_CODE (type) == VECTOR_TYPE)
74 {
75 if (subtype == optab_vector)
76 return TYPE_SATURATING (type) ? unknown_optab : vashl_optab;
77
78 gcc_assert (subtype == optab_scalar);
79 }
80 if (TYPE_SATURATING (type))
81 return TYPE_UNSIGNED (type) ? usashl_optab : ssashl_optab;
82 return ashl_optab;
83
84 case RSHIFT_EXPR:
85 if (TREE_CODE (type) == VECTOR_TYPE)
86 {
87 if (subtype == optab_vector)
88 return TYPE_UNSIGNED (type) ? vlshr_optab : vashr_optab;
89
90 gcc_assert (subtype == optab_scalar);
91 }
92 return TYPE_UNSIGNED (type) ? lshr_optab : ashr_optab;
93
94 case LROTATE_EXPR:
95 if (TREE_CODE (type) == VECTOR_TYPE)
96 {
97 if (subtype == optab_vector)
98 return vrotl_optab;
99
100 gcc_assert (subtype == optab_scalar);
101 }
102 return rotl_optab;
103
104 case RROTATE_EXPR:
105 if (TREE_CODE (type) == VECTOR_TYPE)
106 {
107 if (subtype == optab_vector)
108 return vrotr_optab;
109
110 gcc_assert (subtype == optab_scalar);
111 }
112 return rotr_optab;
113
114 case MAX_EXPR:
115 return TYPE_UNSIGNED (type) ? umax_optab : smax_optab;
116
117 case MIN_EXPR:
118 return TYPE_UNSIGNED (type) ? umin_optab : smin_optab;
119
120 case REALIGN_LOAD_EXPR:
121 return vec_realign_load_optab;
122
123 case WIDEN_SUM_EXPR:
124 return TYPE_UNSIGNED (type) ? usum_widen_optab : ssum_widen_optab;
125
126 case DOT_PROD_EXPR:
127 return TYPE_UNSIGNED (type) ? udot_prod_optab : sdot_prod_optab;
128
129 case SAD_EXPR:
130 return TYPE_UNSIGNED (type) ? usad_optab : ssad_optab;
131
132 case WIDEN_MULT_PLUS_EXPR:
133 return (TYPE_UNSIGNED (type)
134 ? (TYPE_SATURATING (type)
135 ? usmadd_widen_optab : umadd_widen_optab)
136 : (TYPE_SATURATING (type)
137 ? ssmadd_widen_optab : smadd_widen_optab));
138
139 case WIDEN_MULT_MINUS_EXPR:
140 return (TYPE_UNSIGNED (type)
141 ? (TYPE_SATURATING (type)
142 ? usmsub_widen_optab : umsub_widen_optab)
143 : (TYPE_SATURATING (type)
144 ? ssmsub_widen_optab : smsub_widen_optab));
145
146 case FMA_EXPR:
147 return fma_optab;
148
149 case VEC_WIDEN_MULT_HI_EXPR:
150 return TYPE_UNSIGNED (type) ?
151 vec_widen_umult_hi_optab : vec_widen_smult_hi_optab;
152
153 case VEC_WIDEN_MULT_LO_EXPR:
154 return TYPE_UNSIGNED (type) ?
155 vec_widen_umult_lo_optab : vec_widen_smult_lo_optab;
156
157 case VEC_WIDEN_MULT_EVEN_EXPR:
158 return TYPE_UNSIGNED (type) ?
159 vec_widen_umult_even_optab : vec_widen_smult_even_optab;
160
161 case VEC_WIDEN_MULT_ODD_EXPR:
162 return TYPE_UNSIGNED (type) ?
163 vec_widen_umult_odd_optab : vec_widen_smult_odd_optab;
164
165 case VEC_WIDEN_LSHIFT_HI_EXPR:
166 return TYPE_UNSIGNED (type) ?
167 vec_widen_ushiftl_hi_optab : vec_widen_sshiftl_hi_optab;
168
169 case VEC_WIDEN_LSHIFT_LO_EXPR:
170 return TYPE_UNSIGNED (type) ?
171 vec_widen_ushiftl_lo_optab : vec_widen_sshiftl_lo_optab;
172
173 case VEC_UNPACK_HI_EXPR:
174 return TYPE_UNSIGNED (type) ?
175 vec_unpacku_hi_optab : vec_unpacks_hi_optab;
176
177 case VEC_UNPACK_LO_EXPR:
178 return TYPE_UNSIGNED (type) ?
179 vec_unpacku_lo_optab : vec_unpacks_lo_optab;
180
181 case VEC_UNPACK_FLOAT_HI_EXPR:
182 /* The signedness is determined from input operand. */
183 return TYPE_UNSIGNED (type) ?
184 vec_unpacku_float_hi_optab : vec_unpacks_float_hi_optab;
185
186 case VEC_UNPACK_FLOAT_LO_EXPR:
187 /* The signedness is determined from input operand. */
188 return TYPE_UNSIGNED (type) ?
189 vec_unpacku_float_lo_optab : vec_unpacks_float_lo_optab;
190
191 case VEC_PACK_TRUNC_EXPR:
192 return vec_pack_trunc_optab;
193
194 case VEC_PACK_SAT_EXPR:
195 return TYPE_UNSIGNED (type) ? vec_pack_usat_optab : vec_pack_ssat_optab;
196
197 case VEC_PACK_FIX_TRUNC_EXPR:
198 /* The signedness is determined from output operand. */
199 return TYPE_UNSIGNED (type) ?
200 vec_pack_ufix_trunc_optab : vec_pack_sfix_trunc_optab;
201
202 default:
203 break;
204 }
205
206 trapv = INTEGRAL_TYPE_P (type) && TYPE_OVERFLOW_TRAPS (type);
207 switch (code)
208 {
209 case POINTER_PLUS_EXPR:
210 case PLUS_EXPR:
211 if (TYPE_SATURATING (type))
212 return TYPE_UNSIGNED (type) ? usadd_optab : ssadd_optab;
213 return trapv ? addv_optab : add_optab;
214
215 case POINTER_DIFF_EXPR:
216 case MINUS_EXPR:
217 if (TYPE_SATURATING (type))
218 return TYPE_UNSIGNED (type) ? ussub_optab : sssub_optab;
219 return trapv ? subv_optab : sub_optab;
220
221 case MULT_EXPR:
222 if (TYPE_SATURATING (type))
223 return TYPE_UNSIGNED (type) ? usmul_optab : ssmul_optab;
224 return trapv ? smulv_optab : smul_optab;
225
226 case NEGATE_EXPR:
227 if (TYPE_SATURATING (type))
228 return TYPE_UNSIGNED (type) ? usneg_optab : ssneg_optab;
229 return trapv ? negv_optab : neg_optab;
230
231 case ABS_EXPR:
232 return trapv ? absv_optab : abs_optab;
233
234 default:
235 return unknown_optab;
236 }
237}
238
239/* Function supportable_convert_operation
240
241 Check whether an operation represented by the code CODE is a
242 convert operation that is supported by the target platform in
243 vector form (i.e., when operating on arguments of type VECTYPE_IN
244 producing a result of type VECTYPE_OUT).
245
246 Convert operations we currently support directly are FIX_TRUNC and FLOAT.
247 This function checks if these operations are supported
248 by the target platform either directly (via vector tree-codes), or via
249 target builtins.
250
251 Output:
252 - CODE1 is code of vector operation to be used when
253 vectorizing the operation, if available.
254 - DECL is decl of target builtin functions to be used
255 when vectorizing the operation, if available. In this case,
256 CODE1 is CALL_EXPR. */
257
258bool
259supportable_convert_operation (enum tree_code code,
260 tree vectype_out, tree vectype_in,
261 tree *decl, enum tree_code *code1)
262{
263 machine_mode m1,m2;
264 bool truncp;
265
266 m1 = TYPE_MODE (vectype_out);
267 m2 = TYPE_MODE (vectype_in);
268
269 /* First check if we can done conversion directly. */
270 if ((code == FIX_TRUNC_EXPR
271 && can_fix_p (m1,m2,TYPE_UNSIGNED (vectype_out), &truncp)
272 != CODE_FOR_nothing)
273 || (code == FLOAT_EXPR
274 && can_float_p (m1,m2,TYPE_UNSIGNED (vectype_in))
275 != CODE_FOR_nothing))
276 {
277 *code1 = code;
278 return true;
279 }
280
281 /* Now check for builtin. */
282 if (targetm.vectorize.builtin_conversion
283 && targetm.vectorize.builtin_conversion (code, vectype_out, vectype_in))
284 {
285 *code1 = CALL_EXPR;
286 *decl = targetm.vectorize.builtin_conversion (code, vectype_out,
287 vectype_in);
288 return true;
289 }
290 return false;
291}
292
293/* Return TRUE if appropriate vector insn is available
294 for vector comparison expr with vector type VALUE_TYPE
295 and resulting mask with MASK_TYPE. */
296
297bool
298expand_vec_cmp_expr_p (tree value_type, tree mask_type, enum tree_code code)
299{
300 if (get_vec_cmp_icode (TYPE_MODE (value_type), TYPE_MODE (mask_type),
301 TYPE_UNSIGNED (value_type)) != CODE_FOR_nothing)
302 return true;
303 if ((code == EQ_EXPR || code == NE_EXPR)
304 && (get_vec_cmp_eq_icode (TYPE_MODE (value_type), TYPE_MODE (mask_type))
305 != CODE_FOR_nothing))
306 return true;
307 return false;
308}
309
310/* Return TRUE iff, appropriate vector insns are available
311 for vector cond expr with vector type VALUE_TYPE and a comparison
312 with operand vector types in CMP_OP_TYPE. */
313
314bool
315expand_vec_cond_expr_p (tree value_type, tree cmp_op_type, enum tree_code code)
316{
317 machine_mode value_mode = TYPE_MODE (value_type);
318 machine_mode cmp_op_mode = TYPE_MODE (cmp_op_type);
319 if (VECTOR_BOOLEAN_TYPE_P (cmp_op_type)
320 && get_vcond_mask_icode (TYPE_MODE (value_type),
321 TYPE_MODE (cmp_op_type)) != CODE_FOR_nothing)
322 return true;
323
324 if (GET_MODE_SIZE (value_mode) != GET_MODE_SIZE (cmp_op_mode)
325 || GET_MODE_NUNITS (value_mode) != GET_MODE_NUNITS (cmp_op_mode))
326 return false;
327
328 if (get_vcond_icode (TYPE_MODE (value_type), TYPE_MODE (cmp_op_type),
329 TYPE_UNSIGNED (cmp_op_type)) == CODE_FOR_nothing
330 && ((code != EQ_EXPR && code != NE_EXPR)
331 || get_vcond_eq_icode (TYPE_MODE (value_type),
332 TYPE_MODE (cmp_op_type)) == CODE_FOR_nothing))
333 return false;
334
335 return true;
336}
337
338/* Use the current target and options to initialize
339 TREE_OPTIMIZATION_OPTABS (OPTNODE). */
340
341void
342init_tree_optimization_optabs (tree optnode)
343{
344 /* Quick exit if we have already computed optabs for this target. */
345 if (TREE_OPTIMIZATION_BASE_OPTABS (optnode) == this_target_optabs)
346 return;
347
348 /* Forget any previous information and set up for the current target. */
349 TREE_OPTIMIZATION_BASE_OPTABS (optnode) = this_target_optabs;
350 struct target_optabs *tmp_optabs = (struct target_optabs *)
351 TREE_OPTIMIZATION_OPTABS (optnode);
352 if (tmp_optabs)
353 memset (tmp_optabs, 0, sizeof (struct target_optabs));
354 else
355 tmp_optabs = ggc_alloc<target_optabs> ();
356
357 /* Generate a new set of optabs into tmp_optabs. */
358 init_all_optabs (tmp_optabs);
359
360 /* If the optabs changed, record it. */
361 if (memcmp (tmp_optabs, this_target_optabs, sizeof (struct target_optabs)))
362 TREE_OPTIMIZATION_OPTABS (optnode) = tmp_optabs;
363 else
364 {
365 TREE_OPTIMIZATION_OPTABS (optnode) = NULL;
366 ggc_free (tmp_optabs);
367 }
368}
369
370/* Return TRUE if the target has support for vector right shift of an
371 operand of type TYPE. If OT_TYPE is OPTAB_DEFAULT, check for existence
372 of a shift by either a scalar or a vector. Otherwise, check only
373 for a shift that matches OT_TYPE. */
374
375bool
376target_supports_op_p (tree type, enum tree_code code,
377 enum optab_subtype ot_subtype)
378{
379 optab ot = optab_for_tree_code (code, type, ot_subtype);
380 return (ot != unknown_optab
381 && optab_handler (ot, TYPE_MODE (type)) != CODE_FOR_nothing);
382}
383
384