1 /* Tree-based target query functions relating to optabs
2 Copyright (C) 1987-2020 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
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
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/>. */
23 #include "coretypes.h"
25 #include "insn-codes.h"
30 #include "optabs-tree.h"
31 #include "stor-layout.h"
33 /* Return the optab used for computing the operation given by the tree code,
34 CODE and the tree EXP. This function is not always usable (for example, it
35 cannot give complete results for multiplication or division) but probably
36 ought to be relied on more widely throughout the expander. */
38 optab_for_tree_code (enum tree_code code
, const_tree type
,
39 enum optab_subtype subtype
)
51 return one_cmpl_optab
;
56 case MULT_HIGHPART_EXPR
:
57 return TYPE_UNSIGNED (type
) ? umul_highpart_optab
: smul_highpart_optab
;
63 return TYPE_UNSIGNED (type
) ? umod_optab
: smod_optab
;
71 if (TYPE_SATURATING (type
))
72 return TYPE_UNSIGNED (type
) ? usdiv_optab
: ssdiv_optab
;
73 return TYPE_UNSIGNED (type
) ? udiv_optab
: sdiv_optab
;
76 if (TREE_CODE (type
) == VECTOR_TYPE
)
78 if (subtype
== optab_vector
)
79 return TYPE_SATURATING (type
) ? unknown_optab
: vashl_optab
;
81 gcc_assert (subtype
== optab_scalar
);
83 if (TYPE_SATURATING (type
))
84 return TYPE_UNSIGNED (type
) ? usashl_optab
: ssashl_optab
;
88 if (TREE_CODE (type
) == VECTOR_TYPE
)
90 if (subtype
== optab_vector
)
91 return TYPE_UNSIGNED (type
) ? vlshr_optab
: vashr_optab
;
93 gcc_assert (subtype
== optab_scalar
);
95 return TYPE_UNSIGNED (type
) ? lshr_optab
: ashr_optab
;
98 if (TREE_CODE (type
) == VECTOR_TYPE
)
100 if (subtype
== optab_vector
)
103 gcc_assert (subtype
== optab_scalar
);
108 if (TREE_CODE (type
) == VECTOR_TYPE
)
110 if (subtype
== optab_vector
)
113 gcc_assert (subtype
== optab_scalar
);
118 return TYPE_UNSIGNED (type
) ? umax_optab
: smax_optab
;
121 return TYPE_UNSIGNED (type
) ? umin_optab
: smin_optab
;
123 case REALIGN_LOAD_EXPR
:
124 return vec_realign_load_optab
;
127 return TYPE_UNSIGNED (type
) ? usum_widen_optab
: ssum_widen_optab
;
130 return TYPE_UNSIGNED (type
) ? udot_prod_optab
: sdot_prod_optab
;
133 return TYPE_UNSIGNED (type
) ? usad_optab
: ssad_optab
;
135 case WIDEN_MULT_PLUS_EXPR
:
136 return (TYPE_UNSIGNED (type
)
137 ? (TYPE_SATURATING (type
)
138 ? usmadd_widen_optab
: umadd_widen_optab
)
139 : (TYPE_SATURATING (type
)
140 ? ssmadd_widen_optab
: smadd_widen_optab
));
142 case WIDEN_MULT_MINUS_EXPR
:
143 return (TYPE_UNSIGNED (type
)
144 ? (TYPE_SATURATING (type
)
145 ? usmsub_widen_optab
: umsub_widen_optab
)
146 : (TYPE_SATURATING (type
)
147 ? ssmsub_widen_optab
: smsub_widen_optab
));
149 case VEC_WIDEN_MULT_HI_EXPR
:
150 return (TYPE_UNSIGNED (type
)
151 ? vec_widen_umult_hi_optab
: vec_widen_smult_hi_optab
);
153 case VEC_WIDEN_MULT_LO_EXPR
:
154 return (TYPE_UNSIGNED (type
)
155 ? vec_widen_umult_lo_optab
: vec_widen_smult_lo_optab
);
157 case VEC_WIDEN_MULT_EVEN_EXPR
:
158 return (TYPE_UNSIGNED (type
)
159 ? vec_widen_umult_even_optab
: vec_widen_smult_even_optab
);
161 case VEC_WIDEN_MULT_ODD_EXPR
:
162 return (TYPE_UNSIGNED (type
)
163 ? vec_widen_umult_odd_optab
: vec_widen_smult_odd_optab
);
165 case VEC_WIDEN_LSHIFT_HI_EXPR
:
166 return (TYPE_UNSIGNED (type
)
167 ? vec_widen_ushiftl_hi_optab
: vec_widen_sshiftl_hi_optab
);
169 case VEC_WIDEN_LSHIFT_LO_EXPR
:
170 return (TYPE_UNSIGNED (type
)
171 ? vec_widen_ushiftl_lo_optab
: vec_widen_sshiftl_lo_optab
);
173 case VEC_UNPACK_HI_EXPR
:
174 return (TYPE_UNSIGNED (type
)
175 ? vec_unpacku_hi_optab
: vec_unpacks_hi_optab
);
177 case VEC_UNPACK_LO_EXPR
:
178 return (TYPE_UNSIGNED (type
)
179 ? vec_unpacku_lo_optab
: vec_unpacks_lo_optab
);
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
);
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
);
191 case VEC_UNPACK_FIX_TRUNC_HI_EXPR
:
192 /* The signedness is determined from output operand. */
193 return (TYPE_UNSIGNED (type
)
194 ? vec_unpack_ufix_trunc_hi_optab
195 : vec_unpack_sfix_trunc_hi_optab
);
197 case VEC_UNPACK_FIX_TRUNC_LO_EXPR
:
198 /* The signedness is determined from output operand. */
199 return (TYPE_UNSIGNED (type
)
200 ? vec_unpack_ufix_trunc_lo_optab
201 : vec_unpack_sfix_trunc_lo_optab
);
203 case VEC_PACK_TRUNC_EXPR
:
204 return vec_pack_trunc_optab
;
206 case VEC_PACK_SAT_EXPR
:
207 return TYPE_UNSIGNED (type
) ? vec_pack_usat_optab
: vec_pack_ssat_optab
;
209 case VEC_PACK_FIX_TRUNC_EXPR
:
210 /* The signedness is determined from output operand. */
211 return (TYPE_UNSIGNED (type
)
212 ? vec_pack_ufix_trunc_optab
: vec_pack_sfix_trunc_optab
);
214 case VEC_PACK_FLOAT_EXPR
:
215 /* The signedness is determined from input operand. */
216 return (TYPE_UNSIGNED (type
)
217 ? vec_packu_float_optab
: vec_packs_float_optab
);
219 case VEC_DUPLICATE_EXPR
:
220 return vec_duplicate_optab
;
222 case VEC_SERIES_EXPR
:
223 return vec_series_optab
;
229 trapv
= INTEGRAL_TYPE_P (type
) && TYPE_OVERFLOW_TRAPS (type
);
232 case POINTER_PLUS_EXPR
:
234 if (TYPE_SATURATING (type
))
235 return TYPE_UNSIGNED (type
) ? usadd_optab
: ssadd_optab
;
236 return trapv
? addv_optab
: add_optab
;
238 case POINTER_DIFF_EXPR
:
240 if (TYPE_SATURATING (type
))
241 return TYPE_UNSIGNED (type
) ? ussub_optab
: sssub_optab
;
242 return trapv
? subv_optab
: sub_optab
;
245 if (TYPE_SATURATING (type
))
246 return TYPE_UNSIGNED (type
) ? usmul_optab
: ssmul_optab
;
247 return trapv
? smulv_optab
: smul_optab
;
250 if (TYPE_SATURATING (type
))
251 return TYPE_UNSIGNED (type
) ? usneg_optab
: ssneg_optab
;
252 return trapv
? negv_optab
: neg_optab
;
255 return trapv
? absv_optab
: abs_optab
;
260 return unknown_optab
;
264 /* Function supportable_convert_operation
266 Check whether an operation represented by the code CODE is a
267 convert operation that is supported by the target platform in
268 vector form (i.e., when operating on arguments of type VECTYPE_IN
269 producing a result of type VECTYPE_OUT).
271 Convert operations we currently support directly are FIX_TRUNC and FLOAT.
272 This function checks if these operations are supported
273 by the target platform directly (via vector tree-codes).
276 - CODE1 is code of vector operation to be used when
277 vectorizing the operation, if available. */
280 supportable_convert_operation (enum tree_code code
,
281 tree vectype_out
, tree vectype_in
,
282 enum tree_code
*code1
)
287 m1
= TYPE_MODE (vectype_out
);
288 m2
= TYPE_MODE (vectype_in
);
290 /* First check if we can done conversion directly. */
291 if ((code
== FIX_TRUNC_EXPR
292 && can_fix_p (m1
,m2
,TYPE_UNSIGNED (vectype_out
), &truncp
)
294 || (code
== FLOAT_EXPR
295 && can_float_p (m1
,m2
,TYPE_UNSIGNED (vectype_in
))
296 != CODE_FOR_nothing
))
302 if (GET_MODE_UNIT_PRECISION (m1
) > GET_MODE_UNIT_PRECISION (m2
)
303 && can_extend_p (m1
, m2
, TYPE_UNSIGNED (vectype_in
)))
309 if (GET_MODE_UNIT_PRECISION (m1
) < GET_MODE_UNIT_PRECISION (m2
)
310 && convert_optab_handler (trunc_optab
, m1
, m2
) != CODE_FOR_nothing
)
319 /* Return TRUE if appropriate vector insn is available
320 for vector comparison expr with vector type VALUE_TYPE
321 and resulting mask with MASK_TYPE. */
324 expand_vec_cmp_expr_p (tree value_type
, tree mask_type
, enum tree_code code
)
326 if (get_vec_cmp_icode (TYPE_MODE (value_type
), TYPE_MODE (mask_type
),
327 TYPE_UNSIGNED (value_type
)) != CODE_FOR_nothing
)
329 if ((code
== EQ_EXPR
|| code
== NE_EXPR
)
330 && (get_vec_cmp_eq_icode (TYPE_MODE (value_type
), TYPE_MODE (mask_type
))
331 != CODE_FOR_nothing
))
336 /* Return true iff vcond_optab/vcondu_optab can handle a vector
337 comparison for code CODE, comparing operands of type CMP_OP_TYPE and
338 producing a result of type VALUE_TYPE. */
341 vcond_icode_p (tree value_type
, tree cmp_op_type
, enum tree_code code
)
343 return can_vcond_compare_p (get_rtx_code (code
, TYPE_UNSIGNED (cmp_op_type
)),
344 TYPE_MODE (value_type
), TYPE_MODE (cmp_op_type
));
347 /* Return true iff vcondeq_optab can handle a vector comparison for code CODE,
348 comparing operands of type CMP_OP_TYPE and producing a result of type
352 vcond_eq_icode_p (tree value_type
, tree cmp_op_type
, enum tree_code code
)
354 if (code
!= EQ_EXPR
&& code
!= NE_EXPR
)
357 return get_vcond_eq_icode (TYPE_MODE (value_type
), TYPE_MODE (cmp_op_type
))
361 /* Return TRUE iff, appropriate vector insns are available
362 for vector cond expr with vector type VALUE_TYPE and a comparison
363 with operand vector types in CMP_OP_TYPE. */
366 expand_vec_cond_expr_p (tree value_type
, tree cmp_op_type
, enum tree_code code
)
368 machine_mode value_mode
= TYPE_MODE (value_type
);
369 machine_mode cmp_op_mode
= TYPE_MODE (cmp_op_type
);
370 if (VECTOR_BOOLEAN_TYPE_P (cmp_op_type
)
371 && get_vcond_mask_icode (TYPE_MODE (value_type
),
372 TYPE_MODE (cmp_op_type
)) != CODE_FOR_nothing
)
375 if (maybe_ne (GET_MODE_SIZE (value_mode
), GET_MODE_SIZE (cmp_op_mode
))
376 || maybe_ne (GET_MODE_NUNITS (value_mode
), GET_MODE_NUNITS (cmp_op_mode
)))
379 if (TREE_CODE_CLASS (code
) != tcc_comparison
)
380 /* This may happen, for example, if code == SSA_NAME, in which case we
381 cannot be certain whether a vector insn is available. */
384 return vcond_icode_p (value_type
, cmp_op_type
, code
)
385 || vcond_eq_icode_p (value_type
, cmp_op_type
, code
);
388 /* Use the current target and options to initialize
389 TREE_OPTIMIZATION_OPTABS (OPTNODE). */
392 init_tree_optimization_optabs (tree optnode
)
394 /* Quick exit if we have already computed optabs for this target. */
395 if (TREE_OPTIMIZATION_BASE_OPTABS (optnode
) == this_target_optabs
)
398 /* Forget any previous information and set up for the current target. */
399 TREE_OPTIMIZATION_BASE_OPTABS (optnode
) = this_target_optabs
;
400 struct target_optabs
*tmp_optabs
= (struct target_optabs
*)
401 TREE_OPTIMIZATION_OPTABS (optnode
);
403 memset (tmp_optabs
, 0, sizeof (struct target_optabs
));
405 tmp_optabs
= ggc_cleared_alloc
<target_optabs
> ();
407 /* Generate a new set of optabs into tmp_optabs. */
408 init_all_optabs (tmp_optabs
);
410 /* If the optabs changed, record it. */
411 if (memcmp (tmp_optabs
, this_target_optabs
, sizeof (struct target_optabs
)))
412 TREE_OPTIMIZATION_OPTABS (optnode
) = tmp_optabs
;
415 TREE_OPTIMIZATION_OPTABS (optnode
) = NULL
;
416 ggc_free (tmp_optabs
);
420 /* Return TRUE if the target has support for vector right shift of an
421 operand of type TYPE. If OT_TYPE is OPTAB_DEFAULT, check for existence
422 of a shift by either a scalar or a vector. Otherwise, check only
423 for a shift that matches OT_TYPE. */
426 target_supports_op_p (tree type
, enum tree_code code
,
427 enum optab_subtype ot_subtype
)
429 optab ot
= optab_for_tree_code (code
, type
, ot_subtype
);
430 return (ot
!= unknown_optab
431 && optab_handler (ot
, TYPE_MODE (type
)) != CODE_FOR_nothing
);