comparison gcc/optabs-tree.c @ 16:04ced10e8804

gcc 7
author kono
date Fri, 27 Oct 2017 22:46:09 +0900
parents
children 84e7813d76e9
comparison
equal deleted inserted replaced
15:561a7518be6b 16:04ced10e8804
1 /* Tree-based target query functions relating to optabs
2 Copyright (C) 1987-2017 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
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. */
34 optab
35 optab_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 REDUC_MAX_EXPR:
150 return TYPE_UNSIGNED (type)
151 ? reduc_umax_scal_optab : reduc_smax_scal_optab;
152
153 case REDUC_MIN_EXPR:
154 return TYPE_UNSIGNED (type)
155 ? reduc_umin_scal_optab : reduc_smin_scal_optab;
156
157 case REDUC_PLUS_EXPR:
158 return reduc_plus_scal_optab;
159
160 case VEC_WIDEN_MULT_HI_EXPR:
161 return TYPE_UNSIGNED (type) ?
162 vec_widen_umult_hi_optab : vec_widen_smult_hi_optab;
163
164 case VEC_WIDEN_MULT_LO_EXPR:
165 return TYPE_UNSIGNED (type) ?
166 vec_widen_umult_lo_optab : vec_widen_smult_lo_optab;
167
168 case VEC_WIDEN_MULT_EVEN_EXPR:
169 return TYPE_UNSIGNED (type) ?
170 vec_widen_umult_even_optab : vec_widen_smult_even_optab;
171
172 case VEC_WIDEN_MULT_ODD_EXPR:
173 return TYPE_UNSIGNED (type) ?
174 vec_widen_umult_odd_optab : vec_widen_smult_odd_optab;
175
176 case VEC_WIDEN_LSHIFT_HI_EXPR:
177 return TYPE_UNSIGNED (type) ?
178 vec_widen_ushiftl_hi_optab : vec_widen_sshiftl_hi_optab;
179
180 case VEC_WIDEN_LSHIFT_LO_EXPR:
181 return TYPE_UNSIGNED (type) ?
182 vec_widen_ushiftl_lo_optab : vec_widen_sshiftl_lo_optab;
183
184 case VEC_UNPACK_HI_EXPR:
185 return TYPE_UNSIGNED (type) ?
186 vec_unpacku_hi_optab : vec_unpacks_hi_optab;
187
188 case VEC_UNPACK_LO_EXPR:
189 return TYPE_UNSIGNED (type) ?
190 vec_unpacku_lo_optab : vec_unpacks_lo_optab;
191
192 case VEC_UNPACK_FLOAT_HI_EXPR:
193 /* The signedness is determined from input operand. */
194 return TYPE_UNSIGNED (type) ?
195 vec_unpacku_float_hi_optab : vec_unpacks_float_hi_optab;
196
197 case VEC_UNPACK_FLOAT_LO_EXPR:
198 /* The signedness is determined from input operand. */
199 return TYPE_UNSIGNED (type) ?
200 vec_unpacku_float_lo_optab : vec_unpacks_float_lo_optab;
201
202 case VEC_PACK_TRUNC_EXPR:
203 return vec_pack_trunc_optab;
204
205 case VEC_PACK_SAT_EXPR:
206 return TYPE_UNSIGNED (type) ? vec_pack_usat_optab : vec_pack_ssat_optab;
207
208 case VEC_PACK_FIX_TRUNC_EXPR:
209 /* The signedness is determined from output operand. */
210 return TYPE_UNSIGNED (type) ?
211 vec_pack_ufix_trunc_optab : vec_pack_sfix_trunc_optab;
212
213 default:
214 break;
215 }
216
217 trapv = INTEGRAL_TYPE_P (type) && TYPE_OVERFLOW_TRAPS (type);
218 switch (code)
219 {
220 case POINTER_PLUS_EXPR:
221 case PLUS_EXPR:
222 if (TYPE_SATURATING (type))
223 return TYPE_UNSIGNED (type) ? usadd_optab : ssadd_optab;
224 return trapv ? addv_optab : add_optab;
225
226 case MINUS_EXPR:
227 if (TYPE_SATURATING (type))
228 return TYPE_UNSIGNED (type) ? ussub_optab : sssub_optab;
229 return trapv ? subv_optab : sub_optab;
230
231 case MULT_EXPR:
232 if (TYPE_SATURATING (type))
233 return TYPE_UNSIGNED (type) ? usmul_optab : ssmul_optab;
234 return trapv ? smulv_optab : smul_optab;
235
236 case NEGATE_EXPR:
237 if (TYPE_SATURATING (type))
238 return TYPE_UNSIGNED (type) ? usneg_optab : ssneg_optab;
239 return trapv ? negv_optab : neg_optab;
240
241 case ABS_EXPR:
242 return trapv ? absv_optab : abs_optab;
243
244 default:
245 return unknown_optab;
246 }
247 }
248
249 /* Function supportable_convert_operation
250
251 Check whether an operation represented by the code CODE is a
252 convert operation that is supported by the target platform in
253 vector form (i.e., when operating on arguments of type VECTYPE_IN
254 producing a result of type VECTYPE_OUT).
255
256 Convert operations we currently support directly are FIX_TRUNC and FLOAT.
257 This function checks if these operations are supported
258 by the target platform either directly (via vector tree-codes), or via
259 target builtins.
260
261 Output:
262 - CODE1 is code of vector operation to be used when
263 vectorizing the operation, if available.
264 - DECL is decl of target builtin functions to be used
265 when vectorizing the operation, if available. In this case,
266 CODE1 is CALL_EXPR. */
267
268 bool
269 supportable_convert_operation (enum tree_code code,
270 tree vectype_out, tree vectype_in,
271 tree *decl, enum tree_code *code1)
272 {
273 machine_mode m1,m2;
274 bool truncp;
275
276 m1 = TYPE_MODE (vectype_out);
277 m2 = TYPE_MODE (vectype_in);
278
279 /* First check if we can done conversion directly. */
280 if ((code == FIX_TRUNC_EXPR
281 && can_fix_p (m1,m2,TYPE_UNSIGNED (vectype_out), &truncp)
282 != CODE_FOR_nothing)
283 || (code == FLOAT_EXPR
284 && can_float_p (m1,m2,TYPE_UNSIGNED (vectype_in))
285 != CODE_FOR_nothing))
286 {
287 *code1 = code;
288 return true;
289 }
290
291 /* Now check for builtin. */
292 if (targetm.vectorize.builtin_conversion
293 && targetm.vectorize.builtin_conversion (code, vectype_out, vectype_in))
294 {
295 *code1 = CALL_EXPR;
296 *decl = targetm.vectorize.builtin_conversion (code, vectype_out,
297 vectype_in);
298 return true;
299 }
300 return false;
301 }
302
303 /* Return TRUE if appropriate vector insn is available
304 for vector comparison expr with vector type VALUE_TYPE
305 and resulting mask with MASK_TYPE. */
306
307 bool
308 expand_vec_cmp_expr_p (tree value_type, tree mask_type, enum tree_code code)
309 {
310 if (get_vec_cmp_icode (TYPE_MODE (value_type), TYPE_MODE (mask_type),
311 TYPE_UNSIGNED (value_type)) != CODE_FOR_nothing)
312 return true;
313 if ((code == EQ_EXPR || code == NE_EXPR)
314 && (get_vec_cmp_eq_icode (TYPE_MODE (value_type), TYPE_MODE (mask_type))
315 != CODE_FOR_nothing))
316 return true;
317 return false;
318 }
319
320 /* Return TRUE iff, appropriate vector insns are available
321 for vector cond expr with vector type VALUE_TYPE and a comparison
322 with operand vector types in CMP_OP_TYPE. */
323
324 bool
325 expand_vec_cond_expr_p (tree value_type, tree cmp_op_type, enum tree_code code)
326 {
327 machine_mode value_mode = TYPE_MODE (value_type);
328 machine_mode cmp_op_mode = TYPE_MODE (cmp_op_type);
329 if (VECTOR_BOOLEAN_TYPE_P (cmp_op_type)
330 && get_vcond_mask_icode (TYPE_MODE (value_type),
331 TYPE_MODE (cmp_op_type)) != CODE_FOR_nothing)
332 return true;
333
334 if (GET_MODE_SIZE (value_mode) != GET_MODE_SIZE (cmp_op_mode)
335 || GET_MODE_NUNITS (value_mode) != GET_MODE_NUNITS (cmp_op_mode))
336 return false;
337
338 if (get_vcond_icode (TYPE_MODE (value_type), TYPE_MODE (cmp_op_type),
339 TYPE_UNSIGNED (cmp_op_type)) == CODE_FOR_nothing
340 && ((code != EQ_EXPR && code != NE_EXPR)
341 || get_vcond_eq_icode (TYPE_MODE (value_type),
342 TYPE_MODE (cmp_op_type)) == CODE_FOR_nothing))
343 return false;
344
345 return true;
346 }
347
348 /* Use the current target and options to initialize
349 TREE_OPTIMIZATION_OPTABS (OPTNODE). */
350
351 void
352 init_tree_optimization_optabs (tree optnode)
353 {
354 /* Quick exit if we have already computed optabs for this target. */
355 if (TREE_OPTIMIZATION_BASE_OPTABS (optnode) == this_target_optabs)
356 return;
357
358 /* Forget any previous information and set up for the current target. */
359 TREE_OPTIMIZATION_BASE_OPTABS (optnode) = this_target_optabs;
360 struct target_optabs *tmp_optabs = (struct target_optabs *)
361 TREE_OPTIMIZATION_OPTABS (optnode);
362 if (tmp_optabs)
363 memset (tmp_optabs, 0, sizeof (struct target_optabs));
364 else
365 tmp_optabs = ggc_alloc<target_optabs> ();
366
367 /* Generate a new set of optabs into tmp_optabs. */
368 init_all_optabs (tmp_optabs);
369
370 /* If the optabs changed, record it. */
371 if (memcmp (tmp_optabs, this_target_optabs, sizeof (struct target_optabs)))
372 TREE_OPTIMIZATION_OPTABS (optnode) = tmp_optabs;
373 else
374 {
375 TREE_OPTIMIZATION_OPTABS (optnode) = NULL;
376 ggc_free (tmp_optabs);
377 }
378 }
379
380 /* Return TRUE if the target has support for vector right shift of an
381 operand of type TYPE. If OT_TYPE is OPTAB_DEFAULT, check for existence
382 of a shift by either a scalar or a vector. Otherwise, check only
383 for a shift that matches OT_TYPE. */
384
385 bool
386 target_supports_op_p (tree type, enum tree_code code,
387 enum optab_subtype ot_subtype)
388 {
389 optab ot = optab_for_tree_code (code, type, ot_subtype);
390 return (ot != unknown_optab
391 && optab_handler (ot, TYPE_MODE (type)) != CODE_FOR_nothing);
392 }
393