Daily bump.
[official-gcc.git] / gcc / optabs-tree.c
blob1c7181a5748685f9dd77fe0ba04d32935e1d0e3a
1 /* Tree-based target query functions relating to optabs
2 Copyright (C) 1987-2018 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/>. */
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"
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. */
34 optab
35 optab_for_tree_code (enum tree_code code, const_tree type,
36 enum optab_subtype subtype)
38 bool trapv;
39 switch (code)
41 case BIT_AND_EXPR:
42 return and_optab;
44 case BIT_IOR_EXPR:
45 return ior_optab;
47 case BIT_NOT_EXPR:
48 return one_cmpl_optab;
50 case BIT_XOR_EXPR:
51 return xor_optab;
53 case MULT_HIGHPART_EXPR:
54 return TYPE_UNSIGNED (type) ? umul_highpart_optab : smul_highpart_optab;
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;
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;
72 case LSHIFT_EXPR:
73 if (TREE_CODE (type) == VECTOR_TYPE)
75 if (subtype == optab_vector)
76 return TYPE_SATURATING (type) ? unknown_optab : vashl_optab;
78 gcc_assert (subtype == optab_scalar);
80 if (TYPE_SATURATING (type))
81 return TYPE_UNSIGNED (type) ? usashl_optab : ssashl_optab;
82 return ashl_optab;
84 case RSHIFT_EXPR:
85 if (TREE_CODE (type) == VECTOR_TYPE)
87 if (subtype == optab_vector)
88 return TYPE_UNSIGNED (type) ? vlshr_optab : vashr_optab;
90 gcc_assert (subtype == optab_scalar);
92 return TYPE_UNSIGNED (type) ? lshr_optab : ashr_optab;
94 case LROTATE_EXPR:
95 if (TREE_CODE (type) == VECTOR_TYPE)
97 if (subtype == optab_vector)
98 return vrotl_optab;
100 gcc_assert (subtype == optab_scalar);
102 return rotl_optab;
104 case RROTATE_EXPR:
105 if (TREE_CODE (type) == VECTOR_TYPE)
107 if (subtype == optab_vector)
108 return vrotr_optab;
110 gcc_assert (subtype == optab_scalar);
112 return rotr_optab;
114 case MAX_EXPR:
115 return TYPE_UNSIGNED (type) ? umax_optab : smax_optab;
117 case MIN_EXPR:
118 return TYPE_UNSIGNED (type) ? umin_optab : smin_optab;
120 case REALIGN_LOAD_EXPR:
121 return vec_realign_load_optab;
123 case WIDEN_SUM_EXPR:
124 return TYPE_UNSIGNED (type) ? usum_widen_optab : ssum_widen_optab;
126 case DOT_PROD_EXPR:
127 return TYPE_UNSIGNED (type) ? udot_prod_optab : sdot_prod_optab;
129 case SAD_EXPR:
130 return TYPE_UNSIGNED (type) ? usad_optab : ssad_optab;
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));
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));
146 case VEC_WIDEN_MULT_HI_EXPR:
147 return (TYPE_UNSIGNED (type)
148 ? vec_widen_umult_hi_optab : vec_widen_smult_hi_optab);
150 case VEC_WIDEN_MULT_LO_EXPR:
151 return (TYPE_UNSIGNED (type)
152 ? vec_widen_umult_lo_optab : vec_widen_smult_lo_optab);
154 case VEC_WIDEN_MULT_EVEN_EXPR:
155 return (TYPE_UNSIGNED (type)
156 ? vec_widen_umult_even_optab : vec_widen_smult_even_optab);
158 case VEC_WIDEN_MULT_ODD_EXPR:
159 return (TYPE_UNSIGNED (type)
160 ? vec_widen_umult_odd_optab : vec_widen_smult_odd_optab);
162 case VEC_WIDEN_LSHIFT_HI_EXPR:
163 return (TYPE_UNSIGNED (type)
164 ? vec_widen_ushiftl_hi_optab : vec_widen_sshiftl_hi_optab);
166 case VEC_WIDEN_LSHIFT_LO_EXPR:
167 return (TYPE_UNSIGNED (type)
168 ? vec_widen_ushiftl_lo_optab : vec_widen_sshiftl_lo_optab);
170 case VEC_UNPACK_HI_EXPR:
171 return (TYPE_UNSIGNED (type)
172 ? vec_unpacku_hi_optab : vec_unpacks_hi_optab);
174 case VEC_UNPACK_LO_EXPR:
175 return (TYPE_UNSIGNED (type)
176 ? vec_unpacku_lo_optab : vec_unpacks_lo_optab);
178 case VEC_UNPACK_FLOAT_HI_EXPR:
179 /* The signedness is determined from input operand. */
180 return (TYPE_UNSIGNED (type)
181 ? vec_unpacku_float_hi_optab : vec_unpacks_float_hi_optab);
183 case VEC_UNPACK_FLOAT_LO_EXPR:
184 /* The signedness is determined from input operand. */
185 return (TYPE_UNSIGNED (type)
186 ? vec_unpacku_float_lo_optab : vec_unpacks_float_lo_optab);
188 case VEC_UNPACK_FIX_TRUNC_HI_EXPR:
189 /* The signedness is determined from output operand. */
190 return (TYPE_UNSIGNED (type)
191 ? vec_unpack_ufix_trunc_hi_optab
192 : vec_unpack_sfix_trunc_hi_optab);
194 case VEC_UNPACK_FIX_TRUNC_LO_EXPR:
195 /* The signedness is determined from output operand. */
196 return (TYPE_UNSIGNED (type)
197 ? vec_unpack_ufix_trunc_lo_optab
198 : vec_unpack_sfix_trunc_lo_optab);
200 case VEC_PACK_TRUNC_EXPR:
201 return vec_pack_trunc_optab;
203 case VEC_PACK_SAT_EXPR:
204 return TYPE_UNSIGNED (type) ? vec_pack_usat_optab : vec_pack_ssat_optab;
206 case VEC_PACK_FIX_TRUNC_EXPR:
207 /* The signedness is determined from output operand. */
208 return (TYPE_UNSIGNED (type)
209 ? vec_pack_ufix_trunc_optab : vec_pack_sfix_trunc_optab);
211 case VEC_PACK_FLOAT_EXPR:
212 /* The signedness is determined from input operand. */
213 return (TYPE_UNSIGNED (type)
214 ? vec_packu_float_optab : vec_packs_float_optab);
216 case VEC_DUPLICATE_EXPR:
217 return vec_duplicate_optab;
219 case VEC_SERIES_EXPR:
220 return vec_series_optab;
222 default:
223 break;
226 trapv = INTEGRAL_TYPE_P (type) && TYPE_OVERFLOW_TRAPS (type);
227 switch (code)
229 case POINTER_PLUS_EXPR:
230 case PLUS_EXPR:
231 if (TYPE_SATURATING (type))
232 return TYPE_UNSIGNED (type) ? usadd_optab : ssadd_optab;
233 return trapv ? addv_optab : add_optab;
235 case POINTER_DIFF_EXPR:
236 case MINUS_EXPR:
237 if (TYPE_SATURATING (type))
238 return TYPE_UNSIGNED (type) ? ussub_optab : sssub_optab;
239 return trapv ? subv_optab : sub_optab;
241 case MULT_EXPR:
242 if (TYPE_SATURATING (type))
243 return TYPE_UNSIGNED (type) ? usmul_optab : ssmul_optab;
244 return trapv ? smulv_optab : smul_optab;
246 case NEGATE_EXPR:
247 if (TYPE_SATURATING (type))
248 return TYPE_UNSIGNED (type) ? usneg_optab : ssneg_optab;
249 return trapv ? negv_optab : neg_optab;
251 case ABS_EXPR:
252 return trapv ? absv_optab : abs_optab;
254 case ABSU_EXPR:
255 return abs_optab;
256 default:
257 return unknown_optab;
261 /* Function supportable_convert_operation
263 Check whether an operation represented by the code CODE is a
264 convert operation that is supported by the target platform in
265 vector form (i.e., when operating on arguments of type VECTYPE_IN
266 producing a result of type VECTYPE_OUT).
268 Convert operations we currently support directly are FIX_TRUNC and FLOAT.
269 This function checks if these operations are supported
270 by the target platform either directly (via vector tree-codes), or via
271 target builtins.
273 Output:
274 - CODE1 is code of vector operation to be used when
275 vectorizing the operation, if available.
276 - DECL is decl of target builtin functions to be used
277 when vectorizing the operation, if available. In this case,
278 CODE1 is CALL_EXPR. */
280 bool
281 supportable_convert_operation (enum tree_code code,
282 tree vectype_out, tree vectype_in,
283 tree *decl, enum tree_code *code1)
285 machine_mode m1,m2;
286 bool truncp;
288 m1 = TYPE_MODE (vectype_out);
289 m2 = TYPE_MODE (vectype_in);
291 /* First check if we can done conversion directly. */
292 if ((code == FIX_TRUNC_EXPR
293 && can_fix_p (m1,m2,TYPE_UNSIGNED (vectype_out), &truncp)
294 != CODE_FOR_nothing)
295 || (code == FLOAT_EXPR
296 && can_float_p (m1,m2,TYPE_UNSIGNED (vectype_in))
297 != CODE_FOR_nothing))
299 *code1 = code;
300 return true;
303 /* Now check for builtin. */
304 if (targetm.vectorize.builtin_conversion
305 && targetm.vectorize.builtin_conversion (code, vectype_out, vectype_in))
307 *code1 = CALL_EXPR;
308 *decl = targetm.vectorize.builtin_conversion (code, vectype_out,
309 vectype_in);
310 return true;
312 return false;
315 /* Return TRUE if appropriate vector insn is available
316 for vector comparison expr with vector type VALUE_TYPE
317 and resulting mask with MASK_TYPE. */
319 bool
320 expand_vec_cmp_expr_p (tree value_type, tree mask_type, enum tree_code code)
322 if (get_vec_cmp_icode (TYPE_MODE (value_type), TYPE_MODE (mask_type),
323 TYPE_UNSIGNED (value_type)) != CODE_FOR_nothing)
324 return true;
325 if ((code == EQ_EXPR || code == NE_EXPR)
326 && (get_vec_cmp_eq_icode (TYPE_MODE (value_type), TYPE_MODE (mask_type))
327 != CODE_FOR_nothing))
328 return true;
329 return false;
332 /* Return TRUE iff, appropriate vector insns are available
333 for vector cond expr with vector type VALUE_TYPE and a comparison
334 with operand vector types in CMP_OP_TYPE. */
336 bool
337 expand_vec_cond_expr_p (tree value_type, tree cmp_op_type, enum tree_code code)
339 machine_mode value_mode = TYPE_MODE (value_type);
340 machine_mode cmp_op_mode = TYPE_MODE (cmp_op_type);
341 if (VECTOR_BOOLEAN_TYPE_P (cmp_op_type)
342 && get_vcond_mask_icode (TYPE_MODE (value_type),
343 TYPE_MODE (cmp_op_type)) != CODE_FOR_nothing)
344 return true;
346 if (maybe_ne (GET_MODE_SIZE (value_mode), GET_MODE_SIZE (cmp_op_mode))
347 || maybe_ne (GET_MODE_NUNITS (value_mode), GET_MODE_NUNITS (cmp_op_mode)))
348 return false;
350 if (get_vcond_icode (TYPE_MODE (value_type), TYPE_MODE (cmp_op_type),
351 TYPE_UNSIGNED (cmp_op_type)) == CODE_FOR_nothing
352 && ((code != EQ_EXPR && code != NE_EXPR)
353 || get_vcond_eq_icode (TYPE_MODE (value_type),
354 TYPE_MODE (cmp_op_type)) == CODE_FOR_nothing))
355 return false;
357 return true;
360 /* Use the current target and options to initialize
361 TREE_OPTIMIZATION_OPTABS (OPTNODE). */
363 void
364 init_tree_optimization_optabs (tree optnode)
366 /* Quick exit if we have already computed optabs for this target. */
367 if (TREE_OPTIMIZATION_BASE_OPTABS (optnode) == this_target_optabs)
368 return;
370 /* Forget any previous information and set up for the current target. */
371 TREE_OPTIMIZATION_BASE_OPTABS (optnode) = this_target_optabs;
372 struct target_optabs *tmp_optabs = (struct target_optabs *)
373 TREE_OPTIMIZATION_OPTABS (optnode);
374 if (tmp_optabs)
375 memset (tmp_optabs, 0, sizeof (struct target_optabs));
376 else
377 tmp_optabs = ggc_cleared_alloc<target_optabs> ();
379 /* Generate a new set of optabs into tmp_optabs. */
380 init_all_optabs (tmp_optabs);
382 /* If the optabs changed, record it. */
383 if (memcmp (tmp_optabs, this_target_optabs, sizeof (struct target_optabs)))
384 TREE_OPTIMIZATION_OPTABS (optnode) = tmp_optabs;
385 else
387 TREE_OPTIMIZATION_OPTABS (optnode) = NULL;
388 ggc_free (tmp_optabs);
392 /* Return TRUE if the target has support for vector right shift of an
393 operand of type TYPE. If OT_TYPE is OPTAB_DEFAULT, check for existence
394 of a shift by either a scalar or a vector. Otherwise, check only
395 for a shift that matches OT_TYPE. */
397 bool
398 target_supports_op_p (tree type, enum tree_code code,
399 enum optab_subtype ot_subtype)
401 optab ot = optab_for_tree_code (code, type, ot_subtype);
402 return (ot != unknown_optab
403 && optab_handler (ot, TYPE_MODE (type)) != CODE_FOR_nothing);