]> git.ipfire.org Git - thirdparty/gcc.git/blame - gcc/omp-simd-clone.c
projects / thirdparty / gcc.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Update copyright years.
[thirdparty/gcc.git] / gcc / omp-simd-clone.c
CommitLineData
4e4f3d27 1/* OMP constructs' SIMD clone supporting code.
2
fbd26352 3Copyright (C) 2005-2019 Free Software Foundation, Inc.
4e4f3d27 4
5This file is part of GCC.
6
7GCC is free software; you can redistribute it and/or modify it under
8the terms of the GNU General Public License as published by the Free
9Software Foundation; either version 3, or (at your option) any later
10version.
11
12GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13WARRANTY; without even the implied warranty of MERCHANTABILITY or
14FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
15for more details.
16
17You should have received a copy of the GNU General Public License
18along with GCC; see the file COPYING3. If not see
19<http://www.gnu.org/licenses/>. */
20
21#include "config.h"
22#include "system.h"
23#include "coretypes.h"
24#include "backend.h"
25#include "target.h"
26#include "tree.h"
27#include "gimple.h"
28#include "cfghooks.h"
29#include "alloc-pool.h"
30#include "tree-pass.h"
31#include "ssa.h"
32#include "cgraph.h"
33#include "pretty-print.h"
34#include "diagnostic-core.h"
35#include "fold-const.h"
36#include "stor-layout.h"
37#include "cfganal.h"
38#include "gimplify.h"
39#include "gimple-iterator.h"
40#include "gimplify-me.h"
41#include "gimple-walk.h"
42#include "langhooks.h"
43#include "tree-cfg.h"
44#include "tree-into-ssa.h"
45#include "tree-dfa.h"
46#include "cfgloop.h"
47#include "symbol-summary.h"
ac762bff 48#include "ipa-param-manipulation.h"
4e4f3d27 49#include "tree-eh.h"
440837fe 50#include "varasm.h"
30a86690 51#include "stringpool.h"
52#include "attribs.h"
a35ca444 53#include "omp-simd-clone.h"
4e4f3d27 54
8e33ba31 55/* Return the number of elements in vector type VECTYPE, which is associated
56 with a SIMD clone. At present these always have a constant length. */
57
58static unsigned HOST_WIDE_INT
59simd_clone_subparts (tree vectype)
60{
f08ee65f 61 return TYPE_VECTOR_SUBPARTS (vectype).to_constant ();
8e33ba31 62}
63
4e4f3d27 64/* Allocate a fresh `simd_clone' and return it. NARGS is the number
65 of arguments to reserve space for. */
66
67static struct cgraph_simd_clone *
68simd_clone_struct_alloc (int nargs)
69{
70 struct cgraph_simd_clone *clone_info;
71 size_t len = (sizeof (struct cgraph_simd_clone)
72 + nargs * sizeof (struct cgraph_simd_clone_arg));
73 clone_info = (struct cgraph_simd_clone *)
74 ggc_internal_cleared_alloc (len);
75 return clone_info;
76}
77
78/* Make a copy of the `struct cgraph_simd_clone' in FROM to TO. */
79
80static inline void
81simd_clone_struct_copy (struct cgraph_simd_clone *to,
82 struct cgraph_simd_clone *from)
83{
84 memcpy (to, from, (sizeof (struct cgraph_simd_clone)
85 + ((from->nargs - from->inbranch)
86 * sizeof (struct cgraph_simd_clone_arg))));
87}
88
89/* Return vector of parameter types of function FNDECL. This uses
90 TYPE_ARG_TYPES if available, otherwise falls back to types of
91 DECL_ARGUMENTS types. */
92
93static vec<tree>
94simd_clone_vector_of_formal_parm_types (tree fndecl)
95{
96 if (TYPE_ARG_TYPES (TREE_TYPE (fndecl)))
97 return ipa_get_vector_of_formal_parm_types (TREE_TYPE (fndecl));
98 vec<tree> args = ipa_get_vector_of_formal_parms (fndecl);
99 unsigned int i;
100 tree arg;
101 FOR_EACH_VEC_ELT (args, i, arg)
102 args[i] = TREE_TYPE (args[i]);
103 return args;
104}
105
106/* Given a simd function in NODE, extract the simd specific
107 information from the OMP clauses passed in CLAUSES, and return
108 the struct cgraph_simd_clone * if it should be cloned. *INBRANCH_SPECIFIED
109 is set to TRUE if the `inbranch' or `notinbranch' clause specified,
110 otherwise set to FALSE. */
111
112static struct cgraph_simd_clone *
113simd_clone_clauses_extract (struct cgraph_node *node, tree clauses,
114 bool *inbranch_specified)
115{
116 vec<tree> args = simd_clone_vector_of_formal_parm_types (node->decl);
117 tree t;
118 int n;
119 *inbranch_specified = false;
120
121 n = args.length ();
122 if (n > 0 && args.last () == void_type_node)
123 n--;
124
4e4f3d27 125 /* Allocate one more than needed just in case this is an in-branch
126 clone which will require a mask argument. */
127 struct cgraph_simd_clone *clone_info = simd_clone_struct_alloc (n + 1);
128 clone_info->nargs = n;
4e4f3d27 129
130 if (!clauses)
0b80c4b2 131 goto out;
132
4e4f3d27 133 clauses = TREE_VALUE (clauses);
134 if (!clauses || TREE_CODE (clauses) != OMP_CLAUSE)
0b80c4b2 135 goto out;
4e4f3d27 136
137 for (t = clauses; t; t = OMP_CLAUSE_CHAIN (t))
138 {
139 switch (OMP_CLAUSE_CODE (t))
140 {
141 case OMP_CLAUSE_INBRANCH:
142 clone_info->inbranch = 1;
143 *inbranch_specified = true;
144 break;
145 case OMP_CLAUSE_NOTINBRANCH:
146 clone_info->inbranch = 0;
147 *inbranch_specified = true;
148 break;
149 case OMP_CLAUSE_SIMDLEN:
150 clone_info->simdlen
151 = TREE_INT_CST_LOW (OMP_CLAUSE_SIMDLEN_EXPR (t));
152 break;
153 case OMP_CLAUSE_LINEAR:
154 {
155 tree decl = OMP_CLAUSE_DECL (t);
156 tree step = OMP_CLAUSE_LINEAR_STEP (t);
157 int argno = TREE_INT_CST_LOW (decl);
158 if (OMP_CLAUSE_LINEAR_VARIABLE_STRIDE (t))
159 {
160 enum cgraph_simd_clone_arg_type arg_type;
161 if (TREE_CODE (args[argno]) == REFERENCE_TYPE)
162 switch (OMP_CLAUSE_LINEAR_KIND (t))
163 {
164 case OMP_CLAUSE_LINEAR_REF:
165 arg_type
166 = SIMD_CLONE_ARG_TYPE_LINEAR_REF_VARIABLE_STEP;
167 break;
168 case OMP_CLAUSE_LINEAR_UVAL:
169 arg_type
170 = SIMD_CLONE_ARG_TYPE_LINEAR_UVAL_VARIABLE_STEP;
171 break;
172 case OMP_CLAUSE_LINEAR_VAL:
173 case OMP_CLAUSE_LINEAR_DEFAULT:
174 arg_type
175 = SIMD_CLONE_ARG_TYPE_LINEAR_VAL_VARIABLE_STEP;
176 break;
177 default:
178 gcc_unreachable ();
179 }
180 else
181 arg_type = SIMD_CLONE_ARG_TYPE_LINEAR_VARIABLE_STEP;
182 clone_info->args[argno].arg_type = arg_type;
183 clone_info->args[argno].linear_step = tree_to_shwi (step);
184 gcc_assert (clone_info->args[argno].linear_step >= 0
185 && clone_info->args[argno].linear_step < n);
186 }
187 else
188 {
189 if (POINTER_TYPE_P (args[argno]))
190 step = fold_convert (ssizetype, step);
191 if (!tree_fits_shwi_p (step))
192 {
193 warning_at (OMP_CLAUSE_LOCATION (t), 0,
194 "ignoring large linear step");
195 args.release ();
196 return NULL;
197 }
198 else if (integer_zerop (step))
199 {
200 warning_at (OMP_CLAUSE_LOCATION (t), 0,
201 "ignoring zero linear step");
202 args.release ();
203 return NULL;
204 }
205 else
206 {
207 enum cgraph_simd_clone_arg_type arg_type;
208 if (TREE_CODE (args[argno]) == REFERENCE_TYPE)
209 switch (OMP_CLAUSE_LINEAR_KIND (t))
210 {
211 case OMP_CLAUSE_LINEAR_REF:
212 arg_type
213 = SIMD_CLONE_ARG_TYPE_LINEAR_REF_CONSTANT_STEP;
214 break;
215 case OMP_CLAUSE_LINEAR_UVAL:
216 arg_type
217 = SIMD_CLONE_ARG_TYPE_LINEAR_UVAL_CONSTANT_STEP;
218 break;
219 case OMP_CLAUSE_LINEAR_VAL:
220 case OMP_CLAUSE_LINEAR_DEFAULT:
221 arg_type
222 = SIMD_CLONE_ARG_TYPE_LINEAR_VAL_CONSTANT_STEP;
223 break;
224 default:
225 gcc_unreachable ();
226 }
227 else
228 arg_type = SIMD_CLONE_ARG_TYPE_LINEAR_CONSTANT_STEP;
229 clone_info->args[argno].arg_type = arg_type;
230 clone_info->args[argno].linear_step = tree_to_shwi (step);
231 }
232 }
233 break;
234 }
235 case OMP_CLAUSE_UNIFORM:
236 {
237 tree decl = OMP_CLAUSE_DECL (t);
238 int argno = tree_to_uhwi (decl);
239 clone_info->args[argno].arg_type
240 = SIMD_CLONE_ARG_TYPE_UNIFORM;
241 break;
242 }
243 case OMP_CLAUSE_ALIGNED:
244 {
245 tree decl = OMP_CLAUSE_DECL (t);
246 int argno = tree_to_uhwi (decl);
247 clone_info->args[argno].alignment
248 = TREE_INT_CST_LOW (OMP_CLAUSE_ALIGNED_ALIGNMENT (t));
249 break;
250 }
251 default:
252 break;
253 }
254 }
0b80c4b2 255
256 out:
257 if (TYPE_ATOMIC (TREE_TYPE (TREE_TYPE (node->decl))))
258 {
259 warning_at (DECL_SOURCE_LOCATION (node->decl), 0,
260 "ignoring %<#pragma omp declare simd%> on function "
261 "with %<_Atomic%> qualified return type");
262 args.release ();
263 return NULL;
264 }
265
266 for (unsigned int argno = 0; argno < clone_info->nargs; argno++)
267 if (TYPE_ATOMIC (args[argno])
268 && clone_info->args[argno].arg_type != SIMD_CLONE_ARG_TYPE_UNIFORM)
269 {
270 warning_at (DECL_SOURCE_LOCATION (node->decl), 0,
271 "ignoring %<#pragma omp declare simd%> on function "
272 "with %<_Atomic%> qualified non-%<uniform%> argument");
273 args.release ();
274 return NULL;
275 }
276
4e4f3d27 277 args.release ();
278 return clone_info;
279}
280
281/* Given a SIMD clone in NODE, calculate the characteristic data
282 type and return the coresponding type. The characteristic data
283 type is computed as described in the Intel Vector ABI. */
284
285static tree
286simd_clone_compute_base_data_type (struct cgraph_node *node,
287 struct cgraph_simd_clone *clone_info)
288{
289 tree type = integer_type_node;
290 tree fndecl = node->decl;
291
292 /* a) For non-void function, the characteristic data type is the
293 return type. */
294 if (TREE_CODE (TREE_TYPE (TREE_TYPE (fndecl))) != VOID_TYPE)
295 type = TREE_TYPE (TREE_TYPE (fndecl));
296
297 /* b) If the function has any non-uniform, non-linear parameters,
298 then the characteristic data type is the type of the first
299 such parameter. */
300 else
301 {
302 vec<tree> map = simd_clone_vector_of_formal_parm_types (fndecl);
303 for (unsigned int i = 0; i < clone_info->nargs; ++i)
304 if (clone_info->args[i].arg_type == SIMD_CLONE_ARG_TYPE_VECTOR)
305 {
306 type = map[i];
307 break;
308 }
309 map.release ();
310 }
311
312 /* c) If the characteristic data type determined by a) or b) above
313 is struct, union, or class type which is pass-by-value (except
314 for the type that maps to the built-in complex data type), the
315 characteristic data type is int. */
316 if (RECORD_OR_UNION_TYPE_P (type)
317 && !aggregate_value_p (type, NULL)
318 && TREE_CODE (type) != COMPLEX_TYPE)
319 return integer_type_node;
320
321 /* d) If none of the above three classes is applicable, the
322 characteristic data type is int. */
323
324 return type;
325
326 /* e) For Intel Xeon Phi native and offload compilation, if the
327 resulting characteristic data type is 8-bit or 16-bit integer
328 data type, the characteristic data type is int. */
329 /* Well, we don't handle Xeon Phi yet. */
330}
331
332static tree
333simd_clone_mangle (struct cgraph_node *node,
334 struct cgraph_simd_clone *clone_info)
335{
336 char vecsize_mangle = clone_info->vecsize_mangle;
337 char mask = clone_info->inbranch ? 'M' : 'N';
338 unsigned int simdlen = clone_info->simdlen;
339 unsigned int n;
340 pretty_printer pp;
341
342 gcc_assert (vecsize_mangle && simdlen);
343
344 pp_string (&pp, "_ZGV");
345 pp_character (&pp, vecsize_mangle);
346 pp_character (&pp, mask);
347 pp_decimal_int (&pp, simdlen);
348
349 for (n = 0; n < clone_info->nargs; ++n)
350 {
351 struct cgraph_simd_clone_arg arg = clone_info->args[n];
352
353 switch (arg.arg_type)
354 {
355 case SIMD_CLONE_ARG_TYPE_UNIFORM:
356 pp_character (&pp, 'u');
357 break;
358 case SIMD_CLONE_ARG_TYPE_LINEAR_CONSTANT_STEP:
359 pp_character (&pp, 'l');
360 goto mangle_linear;
361 case SIMD_CLONE_ARG_TYPE_LINEAR_REF_CONSTANT_STEP:
362 pp_character (&pp, 'R');
363 goto mangle_linear;
364 case SIMD_CLONE_ARG_TYPE_LINEAR_VAL_CONSTANT_STEP:
365 pp_character (&pp, 'L');
366 goto mangle_linear;
367 case SIMD_CLONE_ARG_TYPE_LINEAR_UVAL_CONSTANT_STEP:
368 pp_character (&pp, 'U');
369 goto mangle_linear;
370 mangle_linear:
371 gcc_assert (arg.linear_step != 0);
372 if (arg.linear_step > 1)
373 pp_unsigned_wide_integer (&pp, arg.linear_step);
374 else if (arg.linear_step < 0)
375 {
376 pp_character (&pp, 'n');
377 pp_unsigned_wide_integer (&pp, (-(unsigned HOST_WIDE_INT)
378 arg.linear_step));
379 }
380 break;
381 case SIMD_CLONE_ARG_TYPE_LINEAR_VARIABLE_STEP:
382 pp_string (&pp, "ls");
383 pp_unsigned_wide_integer (&pp, arg.linear_step);
384 break;
385 case SIMD_CLONE_ARG_TYPE_LINEAR_REF_VARIABLE_STEP:
386 pp_string (&pp, "Rs");
387 pp_unsigned_wide_integer (&pp, arg.linear_step);
388 break;
389 case SIMD_CLONE_ARG_TYPE_LINEAR_VAL_VARIABLE_STEP:
390 pp_string (&pp, "Ls");
391 pp_unsigned_wide_integer (&pp, arg.linear_step);
392 break;
393 case SIMD_CLONE_ARG_TYPE_LINEAR_UVAL_VARIABLE_STEP:
394 pp_string (&pp, "Us");
395 pp_unsigned_wide_integer (&pp, arg.linear_step);
396 break;
397 default:
398 pp_character (&pp, 'v');
399 }
400 if (arg.alignment)
401 {
402 pp_character (&pp, 'a');
403 pp_decimal_int (&pp, arg.alignment);
404 }
405 }
406
407 pp_underscore (&pp);
408 const char *str = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (node->decl));
409 if (*str == '*')
410 ++str;
411 pp_string (&pp, str);
412 str = pp_formatted_text (&pp);
413
414 /* If there already is a SIMD clone with the same mangled name, don't
415 add another one. This can happen e.g. for
416 #pragma omp declare simd
417 #pragma omp declare simd simdlen(8)
418 int foo (int, int);
419 if the simdlen is assumed to be 8 for the first one, etc. */
420 for (struct cgraph_node *clone = node->simd_clones; clone;
421 clone = clone->simdclone->next_clone)
e34c848a 422 if (id_equal (DECL_ASSEMBLER_NAME (clone->decl), str))
4e4f3d27 423 return NULL_TREE;
424
425 return get_identifier (str);
426}
427
428/* Create a simd clone of OLD_NODE and return it. */
429
430static struct cgraph_node *
431simd_clone_create (struct cgraph_node *old_node)
432{
433 struct cgraph_node *new_node;
434 if (old_node->definition)
435 {
436 if (!old_node->has_gimple_body_p ())
437 return NULL;
438 old_node->get_body ();
439 new_node = old_node->create_version_clone_with_body (vNULL, NULL, NULL,
440 false, NULL, NULL,
441 "simdclone");
442 }
443 else
444 {
445 tree old_decl = old_node->decl;
446 tree new_decl = copy_node (old_node->decl);
87943388 447 DECL_NAME (new_decl) = clone_function_name_numbered (old_decl,
448 "simdclone");
4e4f3d27 449 SET_DECL_ASSEMBLER_NAME (new_decl, DECL_NAME (new_decl));
450 SET_DECL_RTL (new_decl, NULL);
451 DECL_STATIC_CONSTRUCTOR (new_decl) = 0;
452 DECL_STATIC_DESTRUCTOR (new_decl) = 0;
453 new_node = old_node->create_version_clone (new_decl, vNULL, NULL);
454 if (old_node->in_other_partition)
455 new_node->in_other_partition = 1;
456 }
457 if (new_node == NULL)
458 return new_node;
459
8664f262 460 DECL_BUILT_IN_CLASS (new_node->decl) = NOT_BUILT_IN;
461 DECL_FUNCTION_CODE (new_node->decl) = (enum built_in_function) 0;
4e4f3d27 462 TREE_PUBLIC (new_node->decl) = TREE_PUBLIC (old_node->decl);
440837fe 463 DECL_COMDAT (new_node->decl) = DECL_COMDAT (old_node->decl);
464 DECL_WEAK (new_node->decl) = DECL_WEAK (old_node->decl);
465 DECL_EXTERNAL (new_node->decl) = DECL_EXTERNAL (old_node->decl);
466 DECL_VISIBILITY_SPECIFIED (new_node->decl)
467 = DECL_VISIBILITY_SPECIFIED (old_node->decl);
468 DECL_VISIBILITY (new_node->decl) = DECL_VISIBILITY (old_node->decl);
469 DECL_DLLIMPORT_P (new_node->decl) = DECL_DLLIMPORT_P (old_node->decl);
470 if (DECL_ONE_ONLY (old_node->decl))
471 make_decl_one_only (new_node->decl, DECL_ASSEMBLER_NAME (new_node->decl));
472
473 /* The method cgraph_version_clone_with_body () will force the new
474 symbol local. Undo this, and inherit external visibility from
4e4f3d27 475 the old node. */
476 new_node->local.local = old_node->local.local;
477 new_node->externally_visible = old_node->externally_visible;
478
479 return new_node;
480}
481
482/* Adjust the return type of the given function to its appropriate
483 vector counterpart. Returns a simd array to be used throughout the
484 function as a return value. */
485
486static tree
487simd_clone_adjust_return_type (struct cgraph_node *node)
488{
489 tree fndecl = node->decl;
490 tree orig_rettype = TREE_TYPE (TREE_TYPE (fndecl));
491 unsigned int veclen;
492 tree t;
493
494 /* Adjust the function return type. */
495 if (orig_rettype == void_type_node)
496 return NULL_TREE;
497 TREE_TYPE (fndecl) = build_distinct_type_copy (TREE_TYPE (fndecl));
498 t = TREE_TYPE (TREE_TYPE (fndecl));
499 if (INTEGRAL_TYPE_P (t) || POINTER_TYPE_P (t))
500 veclen = node->simdclone->vecsize_int;
501 else
502 veclen = node->simdclone->vecsize_float;
3d2b0034 503 veclen /= GET_MODE_BITSIZE (SCALAR_TYPE_MODE (t));
4e4f3d27 504 if (veclen > node->simdclone->simdlen)
505 veclen = node->simdclone->simdlen;
506 if (POINTER_TYPE_P (t))
507 t = pointer_sized_int_node;
508 if (veclen == node->simdclone->simdlen)
509 t = build_vector_type (t, node->simdclone->simdlen);
510 else
511 {
512 t = build_vector_type (t, veclen);
513 t = build_array_type_nelts (t, node->simdclone->simdlen / veclen);
514 }
515 TREE_TYPE (TREE_TYPE (fndecl)) = t;
516 if (!node->definition)
517 return NULL_TREE;
518
519 t = DECL_RESULT (fndecl);
520 /* Adjust the DECL_RESULT. */
521 gcc_assert (TREE_TYPE (t) != void_type_node);
522 TREE_TYPE (t) = TREE_TYPE (TREE_TYPE (fndecl));
523 relayout_decl (t);
524
525 tree atype = build_array_type_nelts (orig_rettype,
526 node->simdclone->simdlen);
527 if (veclen != node->simdclone->simdlen)
528 return build1 (VIEW_CONVERT_EXPR, atype, t);
529
530 /* Set up a SIMD array to use as the return value. */
531 tree retval = create_tmp_var_raw (atype, "retval");
532 gimple_add_tmp_var (retval);
533 return retval;
534}
535
536/* Each vector argument has a corresponding array to be used locally
537 as part of the eventual loop. Create such temporary array and
538 return it.
539
540 PREFIX is the prefix to be used for the temporary.
541
542 TYPE is the inner element type.
543
544 SIMDLEN is the number of elements. */
545
546static tree
547create_tmp_simd_array (const char *prefix, tree type, int simdlen)
548{
549 tree atype = build_array_type_nelts (type, simdlen);
550 tree avar = create_tmp_var_raw (atype, prefix);
551 gimple_add_tmp_var (avar);
552 return avar;
553}
554
555/* Modify the function argument types to their corresponding vector
556 counterparts if appropriate. Also, create one array for each simd
557 argument to be used locally when using the function arguments as
558 part of the loop.
559
560 NODE is the function whose arguments are to be adjusted.
561
562 Returns an adjustment vector that will be filled describing how the
563 argument types will be adjusted. */
564
565static ipa_parm_adjustment_vec
566simd_clone_adjust_argument_types (struct cgraph_node *node)
567{
568 vec<tree> args;
569 ipa_parm_adjustment_vec adjustments;
570
571 if (node->definition)
572 args = ipa_get_vector_of_formal_parms (node->decl);
573 else
574 args = simd_clone_vector_of_formal_parm_types (node->decl);
575 adjustments.create (args.length ());
576 unsigned i, j, veclen;
577 struct ipa_parm_adjustment adj;
578 struct cgraph_simd_clone *sc = node->simdclone;
579
580 for (i = 0; i < sc->nargs; ++i)
581 {
582 memset (&adj, 0, sizeof (adj));
583 tree parm = args[i];
584 tree parm_type = node->definition ? TREE_TYPE (parm) : parm;
585 adj.base_index = i;
586 adj.base = parm;
587
588 sc->args[i].orig_arg = node->definition ? parm : NULL_TREE;
589 sc->args[i].orig_type = parm_type;
590
591 switch (sc->args[i].arg_type)
592 {
593 default:
594 /* No adjustment necessary for scalar arguments. */
595 adj.op = IPA_PARM_OP_COPY;
596 break;
597 case SIMD_CLONE_ARG_TYPE_LINEAR_UVAL_CONSTANT_STEP:
598 case SIMD_CLONE_ARG_TYPE_LINEAR_UVAL_VARIABLE_STEP:
599 if (node->definition)
600 sc->args[i].simd_array
601 = create_tmp_simd_array (IDENTIFIER_POINTER (DECL_NAME (parm)),
602 TREE_TYPE (parm_type),
603 sc->simdlen);
604 adj.op = IPA_PARM_OP_COPY;
605 break;
606 case SIMD_CLONE_ARG_TYPE_LINEAR_VAL_CONSTANT_STEP:
607 case SIMD_CLONE_ARG_TYPE_LINEAR_VAL_VARIABLE_STEP:
608 case SIMD_CLONE_ARG_TYPE_VECTOR:
609 if (INTEGRAL_TYPE_P (parm_type) || POINTER_TYPE_P (parm_type))
610 veclen = sc->vecsize_int;
611 else
612 veclen = sc->vecsize_float;
3d2b0034 613 veclen /= GET_MODE_BITSIZE (SCALAR_TYPE_MODE (parm_type));
4e4f3d27 614 if (veclen > sc->simdlen)
615 veclen = sc->simdlen;
616 adj.arg_prefix = "simd";
617 if (POINTER_TYPE_P (parm_type))
618 adj.type = build_vector_type (pointer_sized_int_node, veclen);
619 else
620 adj.type = build_vector_type (parm_type, veclen);
621 sc->args[i].vector_type = adj.type;
622 for (j = veclen; j < sc->simdlen; j += veclen)
623 {
624 adjustments.safe_push (adj);
625 if (j == veclen)
626 {
627 memset (&adj, 0, sizeof (adj));
628 adj.op = IPA_PARM_OP_NEW;
629 adj.arg_prefix = "simd";
630 adj.base_index = i;
631 adj.type = sc->args[i].vector_type;
632 }
633 }
634
635 if (node->definition)
636 sc->args[i].simd_array
bbfed873 637 = create_tmp_simd_array (DECL_NAME (parm)
638 ? IDENTIFIER_POINTER (DECL_NAME (parm))
639 : NULL, parm_type, sc->simdlen);
4e4f3d27 640 }
641 adjustments.safe_push (adj);
642 }
643
644 if (sc->inbranch)
645 {
646 tree base_type = simd_clone_compute_base_data_type (sc->origin, sc);
647
648 memset (&adj, 0, sizeof (adj));
649 adj.op = IPA_PARM_OP_NEW;
650 adj.arg_prefix = "mask";
651
652 adj.base_index = i;
653 if (INTEGRAL_TYPE_P (base_type) || POINTER_TYPE_P (base_type))
654 veclen = sc->vecsize_int;
655 else
656 veclen = sc->vecsize_float;
3d2b0034 657 veclen /= GET_MODE_BITSIZE (SCALAR_TYPE_MODE (base_type));
4e4f3d27 658 if (veclen > sc->simdlen)
659 veclen = sc->simdlen;
660 if (sc->mask_mode != VOIDmode)
661 adj.type
662 = lang_hooks.types.type_for_mode (sc->mask_mode, 1);
663 else if (POINTER_TYPE_P (base_type))
664 adj.type = build_vector_type (pointer_sized_int_node, veclen);
665 else
666 adj.type = build_vector_type (base_type, veclen);
667 adjustments.safe_push (adj);
668
669 for (j = veclen; j < sc->simdlen; j += veclen)
670 adjustments.safe_push (adj);
671
672 /* We have previously allocated one extra entry for the mask. Use
673 it and fill it. */
674 sc->nargs++;
675 if (sc->mask_mode != VOIDmode)
676 base_type = boolean_type_node;
677 if (node->definition)
678 {
679 sc->args[i].orig_arg
680 = build_decl (UNKNOWN_LOCATION, PARM_DECL, NULL, base_type);
681 if (sc->mask_mode == VOIDmode)
682 sc->args[i].simd_array
683 = create_tmp_simd_array ("mask", base_type, sc->simdlen);
684 else if (veclen < sc->simdlen)
685 sc->args[i].simd_array
686 = create_tmp_simd_array ("mask", adj.type, sc->simdlen / veclen);
687 else
688 sc->args[i].simd_array = NULL_TREE;
689 }
690 sc->args[i].orig_type = base_type;
691 sc->args[i].arg_type = SIMD_CLONE_ARG_TYPE_MASK;
692 }
693
694 if (node->definition)
695 ipa_modify_formal_parameters (node->decl, adjustments);
696 else
697 {
698 tree new_arg_types = NULL_TREE, new_reversed;
699 bool last_parm_void = false;
700 if (args.length () > 0 && args.last () == void_type_node)
701 last_parm_void = true;
702
703 gcc_assert (TYPE_ARG_TYPES (TREE_TYPE (node->decl)));
704 j = adjustments.length ();
705 for (i = 0; i < j; i++)
706 {
707 struct ipa_parm_adjustment *adj = &adjustments[i];
708 tree ptype;
709 if (adj->op == IPA_PARM_OP_COPY)
710 ptype = args[adj->base_index];
711 else
712 ptype = adj->type;
713 new_arg_types = tree_cons (NULL_TREE, ptype, new_arg_types);
714 }
715 new_reversed = nreverse (new_arg_types);
716 if (last_parm_void)
717 {
718 if (new_reversed)
719 TREE_CHAIN (new_arg_types) = void_list_node;
720 else
721 new_reversed = void_list_node;
722 }
723
724 tree new_type = build_distinct_type_copy (TREE_TYPE (node->decl));
725 TYPE_ARG_TYPES (new_type) = new_reversed;
726 TREE_TYPE (node->decl) = new_type;
727
728 adjustments.release ();
729 }
730 args.release ();
731 return adjustments;
732}
733
734/* Initialize and copy the function arguments in NODE to their
735 corresponding local simd arrays. Returns a fresh gimple_seq with
736 the instruction sequence generated. */
737
738static gimple_seq
739simd_clone_init_simd_arrays (struct cgraph_node *node,
740 ipa_parm_adjustment_vec adjustments)
741{
742 gimple_seq seq = NULL;
743 unsigned i = 0, j = 0, k;
744
745 for (tree arg = DECL_ARGUMENTS (node->decl);
746 arg;
747 arg = DECL_CHAIN (arg), i++, j++)
748 {
749 if (adjustments[j].op == IPA_PARM_OP_COPY
750 || POINTER_TYPE_P (TREE_TYPE (arg)))
751 continue;
752
753 node->simdclone->args[i].vector_arg = arg;
754
755 tree array = node->simdclone->args[i].simd_array;
756 if (node->simdclone->mask_mode != VOIDmode
757 && node->simdclone->args[i].arg_type == SIMD_CLONE_ARG_TYPE_MASK)
758 {
759 if (array == NULL_TREE)
760 continue;
761 unsigned int l
762 = tree_to_uhwi (TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (array))));
763 for (k = 0; k <= l; k++)
764 {
765 if (k)
766 {
767 arg = DECL_CHAIN (arg);
768 j++;
769 }
770 tree t = build4 (ARRAY_REF, TREE_TYPE (TREE_TYPE (array)),
771 array, size_int (k), NULL, NULL);
772 t = build2 (MODIFY_EXPR, TREE_TYPE (t), t, arg);
773 gimplify_and_add (t, &seq);
774 }
775 continue;
776 }
8e33ba31 777 if (simd_clone_subparts (TREE_TYPE (arg)) == node->simdclone->simdlen)
4e4f3d27 778 {
779 tree ptype = build_pointer_type (TREE_TYPE (TREE_TYPE (array)));
780 tree ptr = build_fold_addr_expr (array);
781 tree t = build2 (MEM_REF, TREE_TYPE (arg), ptr,
782 build_int_cst (ptype, 0));
783 t = build2 (MODIFY_EXPR, TREE_TYPE (t), t, arg);
784 gimplify_and_add (t, &seq);
785 }
786 else
787 {
8e33ba31 788 unsigned int simdlen = simd_clone_subparts (TREE_TYPE (arg));
4e4f3d27 789 tree ptype = build_pointer_type (TREE_TYPE (TREE_TYPE (array)));
790 for (k = 0; k < node->simdclone->simdlen; k += simdlen)
791 {
792 tree ptr = build_fold_addr_expr (array);
793 int elemsize;
794 if (k)
795 {
796 arg = DECL_CHAIN (arg);
797 j++;
798 }
3d2b0034 799 tree elemtype = TREE_TYPE (TREE_TYPE (arg));
800 elemsize = GET_MODE_SIZE (SCALAR_TYPE_MODE (elemtype));
4e4f3d27 801 tree t = build2 (MEM_REF, TREE_TYPE (arg), ptr,
802 build_int_cst (ptype, k * elemsize));
803 t = build2 (MODIFY_EXPR, TREE_TYPE (t), t, arg);
804 gimplify_and_add (t, &seq);
805 }
806 }
807 }
808 return seq;
809}
810
811/* Callback info for ipa_simd_modify_stmt_ops below. */
812
813struct modify_stmt_info {
814 ipa_parm_adjustment_vec adjustments;
815 gimple *stmt;
816 /* True if the parent statement was modified by
817 ipa_simd_modify_stmt_ops. */
818 bool modified;
819};
820
821/* Callback for walk_gimple_op.
822
823 Adjust operands from a given statement as specified in the
824 adjustments vector in the callback data. */
825
826static tree
827ipa_simd_modify_stmt_ops (tree *tp, int *walk_subtrees, void *data)
828{
829 struct walk_stmt_info *wi = (struct walk_stmt_info *) data;
830 struct modify_stmt_info *info = (struct modify_stmt_info *) wi->info;
831 tree *orig_tp = tp;
832 if (TREE_CODE (*tp) == ADDR_EXPR)
833 tp = &TREE_OPERAND (*tp, 0);
834 struct ipa_parm_adjustment *cand = NULL;
835 if (TREE_CODE (*tp) == PARM_DECL)
836 cand = ipa_get_adjustment_candidate (&tp, NULL, info->adjustments, true);
37e8051e 837 else if (TYPE_P (*tp))
838 *walk_subtrees = 0;
4e4f3d27 839
840 tree repl = NULL_TREE;
841 if (cand)
842 repl = unshare_expr (cand->new_decl);
843 else
844 {
845 if (tp != orig_tp)
846 {
847 *walk_subtrees = 0;
848 bool modified = info->modified;
849 info->modified = false;
850 walk_tree (tp, ipa_simd_modify_stmt_ops, wi, wi->pset);
851 if (!info->modified)
852 {
853 info->modified = modified;
854 return NULL_TREE;
855 }
856 info->modified = modified;
857 repl = *tp;
858 }
859 else
860 return NULL_TREE;
861 }
862
863 if (tp != orig_tp)
864 {
865 repl = build_fold_addr_expr (repl);
866 gimple *stmt;
867 if (is_gimple_debug (info->stmt))
868 {
869 tree vexpr = make_node (DEBUG_EXPR_DECL);
870 stmt = gimple_build_debug_source_bind (vexpr, repl, NULL);
871 DECL_ARTIFICIAL (vexpr) = 1;
872 TREE_TYPE (vexpr) = TREE_TYPE (repl);
adc78298 873 SET_DECL_MODE (vexpr, TYPE_MODE (TREE_TYPE (repl)));
4e4f3d27 874 repl = vexpr;
875 }
876 else
877 {
878 stmt = gimple_build_assign (make_ssa_name (TREE_TYPE (repl)), repl);
879 repl = gimple_assign_lhs (stmt);
880 }
881 gimple_stmt_iterator gsi = gsi_for_stmt (info->stmt);
882 gsi_insert_before (&gsi, stmt, GSI_SAME_STMT);
883 *orig_tp = repl;
884 }
885 else if (!useless_type_conversion_p (TREE_TYPE (*tp), TREE_TYPE (repl)))
886 {
887 tree vce = build1 (VIEW_CONVERT_EXPR, TREE_TYPE (*tp), repl);
888 *tp = vce;
889 }
890 else
891 *tp = repl;
892
893 info->modified = true;
894 return NULL_TREE;
895}
896
897/* Traverse the function body and perform all modifications as
898 described in ADJUSTMENTS. At function return, ADJUSTMENTS will be
899 modified such that the replacement/reduction value will now be an
900 offset into the corresponding simd_array.
901
902 This function will replace all function argument uses with their
903 corresponding simd array elements, and ajust the return values
904 accordingly. */
905
906static void
907ipa_simd_modify_function_body (struct cgraph_node *node,
908 ipa_parm_adjustment_vec adjustments,
909 tree retval_array, tree iter)
910{
911 basic_block bb;
912 unsigned int i, j, l;
913
914 /* Re-use the adjustments array, but this time use it to replace
915 every function argument use to an offset into the corresponding
916 simd_array. */
917 for (i = 0, j = 0; i < node->simdclone->nargs; ++i, ++j)
918 {
919 if (!node->simdclone->args[i].vector_arg)
920 continue;
921
922 tree basetype = TREE_TYPE (node->simdclone->args[i].orig_arg);
923 tree vectype = TREE_TYPE (node->simdclone->args[i].vector_arg);
924 adjustments[j].new_decl
925 = build4 (ARRAY_REF,
926 basetype,
927 node->simdclone->args[i].simd_array,
928 iter,
929 NULL_TREE, NULL_TREE);
930 if (adjustments[j].op == IPA_PARM_OP_NONE
8e33ba31 931 && simd_clone_subparts (vectype) < node->simdclone->simdlen)
932 j += node->simdclone->simdlen / simd_clone_subparts (vectype) - 1;
4e4f3d27 933 }
934
935 l = adjustments.length ();
f211616e 936 tree name;
937
938 FOR_EACH_SSA_NAME (i, name, cfun)
4e4f3d27 939 {
f211616e 940 if (SSA_NAME_VAR (name)
4e4f3d27 941 && TREE_CODE (SSA_NAME_VAR (name)) == PARM_DECL)
942 {
943 for (j = 0; j < l; j++)
944 if (SSA_NAME_VAR (name) == adjustments[j].base
945 && adjustments[j].new_decl)
946 {
947 tree base_var;
948 if (adjustments[j].new_ssa_base == NULL_TREE)
949 {
950 base_var
951 = copy_var_decl (adjustments[j].base,
952 DECL_NAME (adjustments[j].base),
953 TREE_TYPE (adjustments[j].base));
954 adjustments[j].new_ssa_base = base_var;
955 }
956 else
957 base_var = adjustments[j].new_ssa_base;
958 if (SSA_NAME_IS_DEFAULT_DEF (name))
959 {
960 bb = single_succ (ENTRY_BLOCK_PTR_FOR_FN (cfun));
961 gimple_stmt_iterator gsi = gsi_after_labels (bb);
962 tree new_decl = unshare_expr (adjustments[j].new_decl);
963 set_ssa_default_def (cfun, adjustments[j].base, NULL_TREE);
964 SET_SSA_NAME_VAR_OR_IDENTIFIER (name, base_var);
965 SSA_NAME_IS_DEFAULT_DEF (name) = 0;
966 gimple *stmt = gimple_build_assign (name, new_decl);
967 gsi_insert_before (&gsi, stmt, GSI_SAME_STMT);
968 }
969 else
970 SET_SSA_NAME_VAR_OR_IDENTIFIER (name, base_var);
971 }
972 }
973 }
974
975 struct modify_stmt_info info;
976 info.adjustments = adjustments;
977
978 FOR_EACH_BB_FN (bb, DECL_STRUCT_FUNCTION (node->decl))
979 {
980 gimple_stmt_iterator gsi;
981
982 gsi = gsi_start_bb (bb);
983 while (!gsi_end_p (gsi))
984 {
985 gimple *stmt = gsi_stmt (gsi);
986 info.stmt = stmt;
987 struct walk_stmt_info wi;
988
989 memset (&wi, 0, sizeof (wi));
990 info.modified = false;
991 wi.info = &info;
992 walk_gimple_op (stmt, ipa_simd_modify_stmt_ops, &wi);
993
994 if (greturn *return_stmt = dyn_cast <greturn *> (stmt))
995 {
996 tree retval = gimple_return_retval (return_stmt);
fe5d2fc7 997 edge e = find_edge (bb, EXIT_BLOCK_PTR_FOR_FN (cfun));
998 e->flags |= EDGE_FALLTHRU;
4e4f3d27 999 if (!retval)
1000 {
1001 gsi_remove (&gsi, true);
1002 continue;
1003 }
1004
1005 /* Replace `return foo' with `retval_array[iter] = foo'. */
1006 tree ref = build4 (ARRAY_REF, TREE_TYPE (retval),
1007 retval_array, iter, NULL, NULL);
1008 stmt = gimple_build_assign (ref, retval);
1009 gsi_replace (&gsi, stmt, true);
1010 info.modified = true;
1011 }
1012
1013 if (info.modified)
1014 {
1015 update_stmt (stmt);
37e8051e 1016 /* If the above changed the var of a debug bind into something
1017 different, remove the debug stmt. We could also for all the
1018 replaced parameters add VAR_DECLs for debug info purposes,
1019 add debug stmts for those to be the simd array accesses and
1020 replace debug stmt var operand with that var. Debugging of
1021 vectorized loops doesn't work too well, so don't bother for
1022 now. */
1023 if ((gimple_debug_bind_p (stmt)
1024 && !DECL_P (gimple_debug_bind_get_var (stmt)))
1025 || (gimple_debug_source_bind_p (stmt)
1026 && !DECL_P (gimple_debug_source_bind_get_var (stmt))))
1027 {
1028 gsi_remove (&gsi, true);
1029 continue;
1030 }
4e4f3d27 1031 if (maybe_clean_eh_stmt (stmt))
1032 gimple_purge_dead_eh_edges (gimple_bb (stmt));
1033 }
1034 gsi_next (&gsi);
1035 }
1036 }
1037}
1038
1039/* Helper function of simd_clone_adjust, return linear step addend
1040 of Ith argument. */
1041
1042static tree
1043simd_clone_linear_addend (struct cgraph_node *node, unsigned int i,
1044 tree addtype, basic_block entry_bb)
1045{
1046 tree ptype = NULL_TREE;
1047 switch (node->simdclone->args[i].arg_type)
1048 {
1049 case SIMD_CLONE_ARG_TYPE_LINEAR_CONSTANT_STEP:
1050 case SIMD_CLONE_ARG_TYPE_LINEAR_REF_CONSTANT_STEP:
1051 case SIMD_CLONE_ARG_TYPE_LINEAR_VAL_CONSTANT_STEP:
1052 case SIMD_CLONE_ARG_TYPE_LINEAR_UVAL_CONSTANT_STEP:
1053 return build_int_cst (addtype, node->simdclone->args[i].linear_step);
1054 case SIMD_CLONE_ARG_TYPE_LINEAR_VARIABLE_STEP:
1055 case SIMD_CLONE_ARG_TYPE_LINEAR_REF_VARIABLE_STEP:
1056 ptype = TREE_TYPE (node->simdclone->args[i].orig_arg);
1057 break;
1058 case SIMD_CLONE_ARG_TYPE_LINEAR_VAL_VARIABLE_STEP:
1059 case SIMD_CLONE_ARG_TYPE_LINEAR_UVAL_VARIABLE_STEP:
1060 ptype = TREE_TYPE (TREE_TYPE (node->simdclone->args[i].orig_arg));
1061 break;
1062 default:
1063 gcc_unreachable ();
1064 }
1065
1066 unsigned int idx = node->simdclone->args[i].linear_step;
1067 tree arg = node->simdclone->args[idx].orig_arg;
1068 gcc_assert (is_gimple_reg_type (TREE_TYPE (arg)));
1069 gimple_stmt_iterator gsi = gsi_after_labels (entry_bb);
1070 gimple *g;
1071 tree ret;
1072 if (is_gimple_reg (arg))
1073 ret = get_or_create_ssa_default_def (cfun, arg);
1074 else
1075 {
1076 g = gimple_build_assign (make_ssa_name (TREE_TYPE (arg)), arg);
1077 gsi_insert_before (&gsi, g, GSI_SAME_STMT);
1078 ret = gimple_assign_lhs (g);
1079 }
1080 if (TREE_CODE (TREE_TYPE (arg)) == REFERENCE_TYPE)
1081 {
1082 g = gimple_build_assign (make_ssa_name (TREE_TYPE (TREE_TYPE (arg))),
1083 build_simple_mem_ref (ret));
1084 gsi_insert_before (&gsi, g, GSI_SAME_STMT);
1085 ret = gimple_assign_lhs (g);
1086 }
1087 if (!useless_type_conversion_p (addtype, TREE_TYPE (ret)))
1088 {
1089 g = gimple_build_assign (make_ssa_name (addtype), NOP_EXPR, ret);
1090 gsi_insert_before (&gsi, g, GSI_SAME_STMT);
1091 ret = gimple_assign_lhs (g);
1092 }
1093 if (POINTER_TYPE_P (ptype))
1094 {
1095 tree size = TYPE_SIZE_UNIT (TREE_TYPE (ptype));
1096 if (size && TREE_CODE (size) == INTEGER_CST)
1097 {
1098 g = gimple_build_assign (make_ssa_name (addtype), MULT_EXPR,
1099 ret, fold_convert (addtype, size));
1100 gsi_insert_before (&gsi, g, GSI_SAME_STMT);
1101 ret = gimple_assign_lhs (g);
1102 }
1103 }
1104 return ret;
1105}
1106
1107/* Adjust the argument types in NODE to their appropriate vector
1108 counterparts. */
1109
1110static void
1111simd_clone_adjust (struct cgraph_node *node)
1112{
1113 push_cfun (DECL_STRUCT_FUNCTION (node->decl));
1114
1115 targetm.simd_clone.adjust (node);
1116
1117 tree retval = simd_clone_adjust_return_type (node);
1118 ipa_parm_adjustment_vec adjustments
1119 = simd_clone_adjust_argument_types (node);
1120
1121 push_gimplify_context ();
1122
1123 gimple_seq seq = simd_clone_init_simd_arrays (node, adjustments);
1124
1125 /* Adjust all uses of vector arguments accordingly. Adjust all
1126 return values accordingly. */
1127 tree iter = create_tmp_var (unsigned_type_node, "iter");
1128 tree iter1 = make_ssa_name (iter);
b95a2fd4 1129 tree iter2 = NULL_TREE;
4e4f3d27 1130 ipa_simd_modify_function_body (node, adjustments, retval, iter1);
4ff6d41a 1131 adjustments.release ();
4e4f3d27 1132
1133 /* Initialize the iteration variable. */
1134 basic_block entry_bb = single_succ (ENTRY_BLOCK_PTR_FOR_FN (cfun));
1135 basic_block body_bb = split_block_after_labels (entry_bb)->dest;
1136 gimple_stmt_iterator gsi = gsi_after_labels (entry_bb);
1137 /* Insert the SIMD array and iv initialization at function
1138 entry. */
1139 gsi_insert_seq_before (&gsi, seq, GSI_NEW_STMT);
1140
1141 pop_gimplify_context (NULL);
1142
b95a2fd4 1143 gimple *g;
1144 basic_block incr_bb = NULL;
1145 struct loop *loop = NULL;
1146
4e4f3d27 1147 /* Create a new BB right before the original exit BB, to hold the
1148 iteration increment and the condition/branch. */
b95a2fd4 1149 if (EDGE_COUNT (EXIT_BLOCK_PTR_FOR_FN (cfun)->preds))
1150 {
1151 basic_block orig_exit = EDGE_PRED (EXIT_BLOCK_PTR_FOR_FN (cfun), 0)->src;
1152 incr_bb = create_empty_bb (orig_exit);
205ce1aa 1153 incr_bb->count = profile_count::zero ();
b95a2fd4 1154 add_bb_to_loop (incr_bb, body_bb->loop_father);
fe5d2fc7 1155 while (EDGE_COUNT (EXIT_BLOCK_PTR_FOR_FN (cfun)->preds))
b95a2fd4 1156 {
fe5d2fc7 1157 edge e = EDGE_PRED (EXIT_BLOCK_PTR_FOR_FN (cfun), 0);
b95a2fd4 1158 redirect_edge_succ (e, incr_bb);
205ce1aa 1159 incr_bb->count += e->count ();
b95a2fd4 1160 }
1161 }
1162 else if (node->simdclone->inbranch)
1163 {
1164 incr_bb = create_empty_bb (entry_bb);
205ce1aa 1165 incr_bb->count = profile_count::zero ();
b95a2fd4 1166 add_bb_to_loop (incr_bb, body_bb->loop_father);
1167 }
1168
1169 if (incr_bb)
4e4f3d27 1170 {
720cfc43 1171 make_single_succ_edge (incr_bb, EXIT_BLOCK_PTR_FOR_FN (cfun), 0);
b95a2fd4 1172 gsi = gsi_last_bb (incr_bb);
1173 iter2 = make_ssa_name (iter);
1174 g = gimple_build_assign (iter2, PLUS_EXPR, iter1,
1175 build_int_cst (unsigned_type_node, 1));
1176 gsi_insert_after (&gsi, g, GSI_CONTINUE_LINKING);
1177
1178 /* Mostly annotate the loop for the vectorizer (the rest is done
1179 below). */
1180 loop = alloc_loop ();
1181 cfun->has_force_vectorize_loops = true;
1182 loop->safelen = node->simdclone->simdlen;
1183 loop->force_vectorize = true;
1184 loop->header = body_bb;
4e4f3d27 1185 }
4e4f3d27 1186
1187 /* Branch around the body if the mask applies. */
1188 if (node->simdclone->inbranch)
1189 {
b95a2fd4 1190 gsi = gsi_last_bb (loop->header);
4e4f3d27 1191 tree mask_array
1192 = node->simdclone->args[node->simdclone->nargs - 1].simd_array;
1193 tree mask;
1194 if (node->simdclone->mask_mode != VOIDmode)
1195 {
1196 tree shift_cnt;
1197 if (mask_array == NULL_TREE)
1198 {
1199 tree arg = node->simdclone->args[node->simdclone->nargs
1200 - 1].vector_arg;
1201 mask = get_or_create_ssa_default_def (cfun, arg);
1202 shift_cnt = iter1;
1203 }
1204 else
1205 {
1206 tree maskt = TREE_TYPE (mask_array);
1207 int c = tree_to_uhwi (TYPE_MAX_VALUE (TYPE_DOMAIN (maskt)));
1208 c = node->simdclone->simdlen / (c + 1);
1209 int s = exact_log2 (c);
1210 gcc_assert (s > 0);
1211 c--;
1212 tree idx = make_ssa_name (TREE_TYPE (iter1));
1213 g = gimple_build_assign (idx, RSHIFT_EXPR, iter1,
1214 build_int_cst (NULL_TREE, s));
1215 gsi_insert_after (&gsi, g, GSI_CONTINUE_LINKING);
1216 mask = make_ssa_name (TREE_TYPE (TREE_TYPE (mask_array)));
1217 tree aref = build4 (ARRAY_REF,
1218 TREE_TYPE (TREE_TYPE (mask_array)),
1219 mask_array, idx, NULL, NULL);
1220 g = gimple_build_assign (mask, aref);
1221 gsi_insert_after (&gsi, g, GSI_CONTINUE_LINKING);
1222 shift_cnt = make_ssa_name (TREE_TYPE (iter1));
1223 g = gimple_build_assign (shift_cnt, BIT_AND_EXPR, iter1,
1224 build_int_cst (TREE_TYPE (iter1), c));
1225 gsi_insert_after (&gsi, g, GSI_CONTINUE_LINKING);
1226 }
1227 g = gimple_build_assign (make_ssa_name (TREE_TYPE (mask)),
1228 RSHIFT_EXPR, mask, shift_cnt);
1229 gsi_insert_after (&gsi, g, GSI_CONTINUE_LINKING);
1230 mask = gimple_assign_lhs (g);
1231 g = gimple_build_assign (make_ssa_name (TREE_TYPE (mask)),
1232 BIT_AND_EXPR, mask,
1233 build_int_cst (TREE_TYPE (mask), 1));
1234 gsi_insert_after (&gsi, g, GSI_CONTINUE_LINKING);
1235 mask = gimple_assign_lhs (g);
1236 }
1237 else
1238 {
1239 mask = make_ssa_name (TREE_TYPE (TREE_TYPE (mask_array)));
1240 tree aref = build4 (ARRAY_REF,
1241 TREE_TYPE (TREE_TYPE (mask_array)),
1242 mask_array, iter1, NULL, NULL);
1243 g = gimple_build_assign (mask, aref);
1244 gsi_insert_after (&gsi, g, GSI_CONTINUE_LINKING);
3d2b0034 1245 int bitsize = GET_MODE_BITSIZE (SCALAR_TYPE_MODE (TREE_TYPE (aref)));
4e4f3d27 1246 if (!INTEGRAL_TYPE_P (TREE_TYPE (aref)))
1247 {
1248 aref = build1 (VIEW_CONVERT_EXPR,
1249 build_nonstandard_integer_type (bitsize, 0),
1250 mask);
1251 mask = make_ssa_name (TREE_TYPE (aref));
1252 g = gimple_build_assign (mask, aref);
1253 gsi_insert_after (&gsi, g, GSI_CONTINUE_LINKING);
1254 }
1255 }
1256
1257 g = gimple_build_cond (EQ_EXPR, mask, build_zero_cst (TREE_TYPE (mask)),
1258 NULL, NULL);
1259 gsi_insert_after (&gsi, g, GSI_CONTINUE_LINKING);
43eb6d3b 1260 edge e = make_edge (loop->header, incr_bb, EDGE_TRUE_VALUE);
1261 e->probability = profile_probability::unlikely ().guessed ();
205ce1aa 1262 incr_bb->count += e->count ();
43eb6d3b 1263 edge fallthru = FALLTHRU_EDGE (loop->header);
1264 fallthru->flags = EDGE_FALSE_VALUE;
1265 fallthru->probability = profile_probability::likely ().guessed ();
4e4f3d27 1266 }
1267
b95a2fd4 1268 basic_block latch_bb = NULL;
1269 basic_block new_exit_bb = NULL;
1270
4e4f3d27 1271 /* Generate the condition. */
b95a2fd4 1272 if (incr_bb)
1273 {
1274 gsi = gsi_last_bb (incr_bb);
1275 g = gimple_build_cond (LT_EXPR, iter2,
1276 build_int_cst (unsigned_type_node,
1277 node->simdclone->simdlen),
1278 NULL, NULL);
1279 gsi_insert_after (&gsi, g, GSI_CONTINUE_LINKING);
1280 edge e = split_block (incr_bb, gsi_stmt (gsi));
1281 latch_bb = e->dest;
1282 new_exit_bb = split_block_after_labels (latch_bb)->dest;
1283 loop->latch = latch_bb;
1284
1285 redirect_edge_succ (FALLTHRU_EDGE (latch_bb), body_bb);
1286
720cfc43 1287 edge new_e = make_edge (incr_bb, new_exit_bb, EDGE_FALSE_VALUE);
1288
1289 /* FIXME: Do we need to distribute probabilities for the conditional? */
1290 new_e->probability = profile_probability::guessed_never ();
b95a2fd4 1291 /* The successor of incr_bb is already pointing to latch_bb; just
1292 change the flags.
1293 make_edge (incr_bb, latch_bb, EDGE_TRUE_VALUE); */
1294 FALLTHRU_EDGE (incr_bb)->flags = EDGE_TRUE_VALUE;
1295 }
4e4f3d27 1296
1297 gphi *phi = create_phi_node (iter1, body_bb);
1298 edge preheader_edge = find_edge (entry_bb, body_bb);
b95a2fd4 1299 edge latch_edge = NULL;
4e4f3d27 1300 add_phi_arg (phi, build_zero_cst (unsigned_type_node), preheader_edge,
1301 UNKNOWN_LOCATION);
b95a2fd4 1302 if (incr_bb)
4e4f3d27 1303 {
b95a2fd4 1304 latch_edge = single_succ_edge (latch_bb);
1305 add_phi_arg (phi, iter2, latch_edge, UNKNOWN_LOCATION);
1306
1307 /* Generate the new return. */
1308 gsi = gsi_last_bb (new_exit_bb);
1309 if (retval
1310 && TREE_CODE (retval) == VIEW_CONVERT_EXPR
1311 && TREE_CODE (TREE_OPERAND (retval, 0)) == RESULT_DECL)
1312 retval = TREE_OPERAND (retval, 0);
1313 else if (retval)
1314 {
1315 retval = build1 (VIEW_CONVERT_EXPR,
1316 TREE_TYPE (TREE_TYPE (node->decl)),
1317 retval);
1318 retval = force_gimple_operand_gsi (&gsi, retval, true, NULL,
1319 false, GSI_CONTINUE_LINKING);
1320 }
1321 g = gimple_build_return (retval);
1322 gsi_insert_after (&gsi, g, GSI_CONTINUE_LINKING);
4e4f3d27 1323 }
4e4f3d27 1324
1325 /* Handle aligned clauses by replacing default defs of the aligned
1326 uniform args with __builtin_assume_aligned (arg_N(D), alignment)
1327 lhs. Handle linear by adding PHIs. */
1328 for (unsigned i = 0; i < node->simdclone->nargs; i++)
1329 if (node->simdclone->args[i].arg_type == SIMD_CLONE_ARG_TYPE_UNIFORM
1330 && (TREE_ADDRESSABLE (node->simdclone->args[i].orig_arg)
1331 || !is_gimple_reg_type
1332 (TREE_TYPE (node->simdclone->args[i].orig_arg))))
1333 {
1334 tree orig_arg = node->simdclone->args[i].orig_arg;
1335 if (is_gimple_reg_type (TREE_TYPE (orig_arg)))
1336 iter1 = make_ssa_name (TREE_TYPE (orig_arg));
1337 else
1338 {
1339 iter1 = create_tmp_var_raw (TREE_TYPE (orig_arg));
1340 gimple_add_tmp_var (iter1);
1341 }
1342 gsi = gsi_after_labels (entry_bb);
1343 g = gimple_build_assign (iter1, orig_arg);
1344 gsi_insert_before (&gsi, g, GSI_NEW_STMT);
1345 gsi = gsi_after_labels (body_bb);
1346 g = gimple_build_assign (orig_arg, iter1);
1347 gsi_insert_before (&gsi, g, GSI_NEW_STMT);
1348 }
1349 else if (node->simdclone->args[i].arg_type == SIMD_CLONE_ARG_TYPE_UNIFORM
1350 && DECL_BY_REFERENCE (node->simdclone->args[i].orig_arg)
1351 && TREE_CODE (TREE_TYPE (node->simdclone->args[i].orig_arg))
1352 == REFERENCE_TYPE
1353 && TREE_ADDRESSABLE
1354 (TREE_TYPE (TREE_TYPE (node->simdclone->args[i].orig_arg))))
1355 {
1356 tree orig_arg = node->simdclone->args[i].orig_arg;
1357 tree def = ssa_default_def (cfun, orig_arg);
1358 if (def && !has_zero_uses (def))
1359 {
1360 iter1 = create_tmp_var_raw (TREE_TYPE (TREE_TYPE (orig_arg)));
1361 gimple_add_tmp_var (iter1);
1362 gsi = gsi_after_labels (entry_bb);
1363 g = gimple_build_assign (iter1, build_simple_mem_ref (def));
1364 gsi_insert_before (&gsi, g, GSI_NEW_STMT);
1365 gsi = gsi_after_labels (body_bb);
1366 g = gimple_build_assign (build_simple_mem_ref (def), iter1);
1367 gsi_insert_before (&gsi, g, GSI_NEW_STMT);
1368 }
1369 }
1370 else if (node->simdclone->args[i].alignment
1371 && node->simdclone->args[i].arg_type
1372 == SIMD_CLONE_ARG_TYPE_UNIFORM
1373 && (node->simdclone->args[i].alignment
1374 & (node->simdclone->args[i].alignment - 1)) == 0
1375 && TREE_CODE (TREE_TYPE (node->simdclone->args[i].orig_arg))
1376 == POINTER_TYPE)
1377 {
1378 unsigned int alignment = node->simdclone->args[i].alignment;
1379 tree orig_arg = node->simdclone->args[i].orig_arg;
1380 tree def = ssa_default_def (cfun, orig_arg);
1381 if (def && !has_zero_uses (def))
1382 {
1383 tree fn = builtin_decl_explicit (BUILT_IN_ASSUME_ALIGNED);
1384 gimple_seq seq = NULL;
1385 bool need_cvt = false;
1386 gcall *call
1387 = gimple_build_call (fn, 2, def, size_int (alignment));
1388 g = call;
1389 if (!useless_type_conversion_p (TREE_TYPE (orig_arg),
1390 ptr_type_node))
1391 need_cvt = true;
1392 tree t = make_ssa_name (need_cvt ? ptr_type_node : orig_arg);
1393 gimple_call_set_lhs (g, t);
1394 gimple_seq_add_stmt_without_update (&seq, g);
1395 if (need_cvt)
1396 {
1397 t = make_ssa_name (orig_arg);
1398 g = gimple_build_assign (t, NOP_EXPR, gimple_call_lhs (g));
1399 gimple_seq_add_stmt_without_update (&seq, g);
1400 }
1401 gsi_insert_seq_on_edge_immediate
1402 (single_succ_edge (ENTRY_BLOCK_PTR_FOR_FN (cfun)), seq);
1403
1404 entry_bb = single_succ (ENTRY_BLOCK_PTR_FOR_FN (cfun));
4e4f3d27 1405 node->create_edge (cgraph_node::get_create (fn),
151b9ff5 1406 call, entry_bb->count);
4e4f3d27 1407
1408 imm_use_iterator iter;
1409 use_operand_p use_p;
1410 gimple *use_stmt;
1411 tree repl = gimple_get_lhs (g);
1412 FOR_EACH_IMM_USE_STMT (use_stmt, iter, def)
1413 if (is_gimple_debug (use_stmt) || use_stmt == call)
1414 continue;
1415 else
1416 FOR_EACH_IMM_USE_ON_STMT (use_p, iter)
1417 SET_USE (use_p, repl);
1418 }
1419 }
1420 else if ((node->simdclone->args[i].arg_type
1421 == SIMD_CLONE_ARG_TYPE_LINEAR_CONSTANT_STEP)
1422 || (node->simdclone->args[i].arg_type
1423 == SIMD_CLONE_ARG_TYPE_LINEAR_REF_CONSTANT_STEP)
1424 || (node->simdclone->args[i].arg_type
1425 == SIMD_CLONE_ARG_TYPE_LINEAR_VARIABLE_STEP)
1426 || (node->simdclone->args[i].arg_type
1427 == SIMD_CLONE_ARG_TYPE_LINEAR_REF_VARIABLE_STEP))
1428 {
1429 tree orig_arg = node->simdclone->args[i].orig_arg;
1430 gcc_assert (INTEGRAL_TYPE_P (TREE_TYPE (orig_arg))
1431 || POINTER_TYPE_P (TREE_TYPE (orig_arg)));
1432 tree def = NULL_TREE;
1433 if (TREE_ADDRESSABLE (orig_arg))
1434 {
1435 def = make_ssa_name (TREE_TYPE (orig_arg));
1436 iter1 = make_ssa_name (TREE_TYPE (orig_arg));
b95a2fd4 1437 if (incr_bb)
1438 iter2 = make_ssa_name (TREE_TYPE (orig_arg));
4e4f3d27 1439 gsi = gsi_after_labels (entry_bb);
1440 g = gimple_build_assign (def, orig_arg);
1441 gsi_insert_before (&gsi, g, GSI_NEW_STMT);
1442 }
1443 else
1444 {
1445 def = ssa_default_def (cfun, orig_arg);
1446 if (!def || has_zero_uses (def))
1447 def = NULL_TREE;
1448 else
1449 {
1450 iter1 = make_ssa_name (orig_arg);
b95a2fd4 1451 if (incr_bb)
1452 iter2 = make_ssa_name (orig_arg);
4e4f3d27 1453 }
1454 }
1455 if (def)
1456 {
1457 phi = create_phi_node (iter1, body_bb);
1458 add_phi_arg (phi, def, preheader_edge, UNKNOWN_LOCATION);
b95a2fd4 1459 if (incr_bb)
1460 {
1461 add_phi_arg (phi, iter2, latch_edge, UNKNOWN_LOCATION);
1462 enum tree_code code = INTEGRAL_TYPE_P (TREE_TYPE (orig_arg))
1463 ? PLUS_EXPR : POINTER_PLUS_EXPR;
1464 tree addtype = INTEGRAL_TYPE_P (TREE_TYPE (orig_arg))
1465 ? TREE_TYPE (orig_arg) : sizetype;
1466 tree addcst = simd_clone_linear_addend (node, i, addtype,
1467 entry_bb);
1468 gsi = gsi_last_bb (incr_bb);
1469 g = gimple_build_assign (iter2, code, iter1, addcst);
1470 gsi_insert_before (&gsi, g, GSI_SAME_STMT);
1471 }
4e4f3d27 1472
1473 imm_use_iterator iter;
1474 use_operand_p use_p;
1475 gimple *use_stmt;
1476 if (TREE_ADDRESSABLE (orig_arg))
1477 {
1478 gsi = gsi_after_labels (body_bb);
1479 g = gimple_build_assign (orig_arg, iter1);
1480 gsi_insert_before (&gsi, g, GSI_NEW_STMT);
1481 }
1482 else
1483 FOR_EACH_IMM_USE_STMT (use_stmt, iter, def)
1484 if (use_stmt == phi)
1485 continue;
1486 else
1487 FOR_EACH_IMM_USE_ON_STMT (use_p, iter)
1488 SET_USE (use_p, iter1);
1489 }
1490 }
1491 else if (node->simdclone->args[i].arg_type
1492 == SIMD_CLONE_ARG_TYPE_LINEAR_UVAL_CONSTANT_STEP
1493 || (node->simdclone->args[i].arg_type
1494 == SIMD_CLONE_ARG_TYPE_LINEAR_UVAL_VARIABLE_STEP))
1495 {
1496 tree orig_arg = node->simdclone->args[i].orig_arg;
1497 tree def = ssa_default_def (cfun, orig_arg);
1498 gcc_assert (!TREE_ADDRESSABLE (orig_arg)
1499 && TREE_CODE (TREE_TYPE (orig_arg)) == REFERENCE_TYPE);
1500 if (def && !has_zero_uses (def))
1501 {
1502 tree rtype = TREE_TYPE (TREE_TYPE (orig_arg));
1503 iter1 = make_ssa_name (orig_arg);
b95a2fd4 1504 if (incr_bb)
1505 iter2 = make_ssa_name (orig_arg);
4e4f3d27 1506 tree iter3 = make_ssa_name (rtype);
1507 tree iter4 = make_ssa_name (rtype);
b95a2fd4 1508 tree iter5 = incr_bb ? make_ssa_name (rtype) : NULL_TREE;
4e4f3d27 1509 gsi = gsi_after_labels (entry_bb);
1510 gimple *load
1511 = gimple_build_assign (iter3, build_simple_mem_ref (def));
1512 gsi_insert_before (&gsi, load, GSI_NEW_STMT);
1513
1514 tree array = node->simdclone->args[i].simd_array;
1515 TREE_ADDRESSABLE (array) = 1;
1516 tree ptr = build_fold_addr_expr (array);
1517 phi = create_phi_node (iter1, body_bb);
1518 add_phi_arg (phi, ptr, preheader_edge, UNKNOWN_LOCATION);
b95a2fd4 1519 if (incr_bb)
1520 {
1521 add_phi_arg (phi, iter2, latch_edge, UNKNOWN_LOCATION);
1522 g = gimple_build_assign (iter2, POINTER_PLUS_EXPR, iter1,
1523 TYPE_SIZE_UNIT (TREE_TYPE (iter3)));
1524 gsi = gsi_last_bb (incr_bb);
1525 gsi_insert_before (&gsi, g, GSI_SAME_STMT);
1526 }
4e4f3d27 1527
1528 phi = create_phi_node (iter4, body_bb);
1529 add_phi_arg (phi, iter3, preheader_edge, UNKNOWN_LOCATION);
b95a2fd4 1530 if (incr_bb)
1531 {
1532 add_phi_arg (phi, iter5, latch_edge, UNKNOWN_LOCATION);
1533 enum tree_code code = INTEGRAL_TYPE_P (TREE_TYPE (iter3))
1534 ? PLUS_EXPR : POINTER_PLUS_EXPR;
1535 tree addtype = INTEGRAL_TYPE_P (TREE_TYPE (iter3))
1536 ? TREE_TYPE (iter3) : sizetype;
1537 tree addcst = simd_clone_linear_addend (node, i, addtype,
1538 entry_bb);
1539 g = gimple_build_assign (iter5, code, iter4, addcst);
1540 gsi = gsi_last_bb (incr_bb);
1541 gsi_insert_before (&gsi, g, GSI_SAME_STMT);
1542 }
4e4f3d27 1543
1544 g = gimple_build_assign (build_simple_mem_ref (iter1), iter4);
1545 gsi = gsi_after_labels (body_bb);
1546 gsi_insert_before (&gsi, g, GSI_SAME_STMT);
1547
1548 imm_use_iterator iter;
1549 use_operand_p use_p;
1550 gimple *use_stmt;
1551 FOR_EACH_IMM_USE_STMT (use_stmt, iter, def)
1552 if (use_stmt == load)
1553 continue;
1554 else
1555 FOR_EACH_IMM_USE_ON_STMT (use_p, iter)
1556 SET_USE (use_p, iter1);
1557
b95a2fd4 1558 if (!TYPE_READONLY (rtype) && incr_bb)
4e4f3d27 1559 {
1560 tree v = make_ssa_name (rtype);
1561 tree aref = build4 (ARRAY_REF, rtype, array,
1562 size_zero_node, NULL_TREE,
1563 NULL_TREE);
1564 gsi = gsi_after_labels (new_exit_bb);
1565 g = gimple_build_assign (v, aref);
1566 gsi_insert_before (&gsi, g, GSI_SAME_STMT);
1567 g = gimple_build_assign (build_simple_mem_ref (def), v);
1568 gsi_insert_before (&gsi, g, GSI_SAME_STMT);
1569 }
1570 }
1571 }
1572
1573 calculate_dominance_info (CDI_DOMINATORS);
b95a2fd4 1574 if (loop)
1575 add_loop (loop, loop->header->loop_father);
4e4f3d27 1576 update_ssa (TODO_update_ssa);
1577
1578 pop_cfun ();
1579}
1580
1581/* If the function in NODE is tagged as an elemental SIMD function,
1582 create the appropriate SIMD clones. */
1583
a35ca444 1584void
4e4f3d27 1585expand_simd_clones (struct cgraph_node *node)
1586{
1587 tree attr = lookup_attribute ("omp declare simd",
1588 DECL_ATTRIBUTES (node->decl));
1589 if (attr == NULL_TREE
1590 || node->global.inlined_to
1591 || lookup_attribute ("noclone", DECL_ATTRIBUTES (node->decl)))
1592 return;
1593
1594 /* Ignore
1595 #pragma omp declare simd
1596 extern int foo ();
1597 in C, there we don't know the argument types at all. */
1598 if (!node->definition
1599 && TYPE_ARG_TYPES (TREE_TYPE (node->decl)) == NULL_TREE)
1600 return;
1601
1602 /* Call this before creating clone_info, as it might ggc_collect. */
1603 if (node->definition && node->has_gimple_body_p ())
1604 node->get_body ();
1605
1606 do
1607 {
1608 /* Start with parsing the "omp declare simd" attribute(s). */
1609 bool inbranch_clause_specified;
1610 struct cgraph_simd_clone *clone_info
1611 = simd_clone_clauses_extract (node, TREE_VALUE (attr),
1612 &inbranch_clause_specified);
1613 if (clone_info == NULL)
1614 continue;
1615
1616 int orig_simdlen = clone_info->simdlen;
1617 tree base_type = simd_clone_compute_base_data_type (node, clone_info);
1618 /* The target can return 0 (no simd clones should be created),
1619 1 (just one ISA of simd clones should be created) or higher
1620 count of ISA variants. In that case, clone_info is initialized
1621 for the first ISA variant. */
1622 int count
1623 = targetm.simd_clone.compute_vecsize_and_simdlen (node, clone_info,
1624 base_type, 0);
1625 if (count == 0)
1626 continue;
1627
1628 /* Loop over all COUNT ISA variants, and if !INBRANCH_CLAUSE_SPECIFIED,
1629 also create one inbranch and one !inbranch clone of it. */
1630 for (int i = 0; i < count * 2; i++)
1631 {
1632 struct cgraph_simd_clone *clone = clone_info;
1633 if (inbranch_clause_specified && (i & 1) != 0)
1634 continue;
1635
1636 if (i != 0)
1637 {
1638 clone = simd_clone_struct_alloc (clone_info->nargs
1639 + ((i & 1) != 0));
1640 simd_clone_struct_copy (clone, clone_info);
1641 /* Undo changes targetm.simd_clone.compute_vecsize_and_simdlen
1642 and simd_clone_adjust_argument_types did to the first
1643 clone's info. */
1644 clone->nargs -= clone_info->inbranch;
1645 clone->simdlen = orig_simdlen;
1646 /* And call the target hook again to get the right ISA. */
1647 targetm.simd_clone.compute_vecsize_and_simdlen (node, clone,
1648 base_type,
1649 i / 2);
1650 if ((i & 1) != 0)
1651 clone->inbranch = 1;
1652 }
1653
1654 /* simd_clone_mangle might fail if such a clone has been created
1655 already. */
1656 tree id = simd_clone_mangle (node, clone);
1657 if (id == NULL_TREE)
1658 continue;
1659
1660 /* Only when we are sure we want to create the clone actually
1661 clone the function (or definitions) or create another
1662 extern FUNCTION_DECL (for prototypes without definitions). */
1663 struct cgraph_node *n = simd_clone_create (node);
1664 if (n == NULL)
1665 continue;
1666
1667 n->simdclone = clone;
1668 clone->origin = node;
1669 clone->next_clone = NULL;
1670 if (node->simd_clones == NULL)
1671 {
1672 clone->prev_clone = n;
1673 node->simd_clones = n;
1674 }
1675 else
1676 {
1677 clone->prev_clone = node->simd_clones->simdclone->prev_clone;
1678 clone->prev_clone->simdclone->next_clone = n;
1679 node->simd_clones->simdclone->prev_clone = n;
1680 }
1681 symtab->change_decl_assembler_name (n->decl, id);
1682 /* And finally adjust the return type, parameters and for
1683 definitions also function body. */
1684 if (node->definition)
1685 simd_clone_adjust (n);
1686 else
1687 {
1688 simd_clone_adjust_return_type (n);
1689 simd_clone_adjust_argument_types (n);
1690 }
1691 }
1692 }
1693 while ((attr = lookup_attribute ("omp declare simd", TREE_CHAIN (attr))));
1694}
1695
1696/* Entry point for IPA simd clone creation pass. */
1697
1698static unsigned int
1699ipa_omp_simd_clone (void)
1700{
1701 struct cgraph_node *node;
1702 FOR_EACH_FUNCTION (node)
1703 expand_simd_clones (node);
1704 return 0;
1705}
1706
1707namespace {
1708
1709const pass_data pass_data_omp_simd_clone =
1710{
1711 SIMPLE_IPA_PASS, /* type */
1712 "simdclone", /* name */
7246f446 1713 OPTGROUP_OMP, /* optinfo_flags */
4e4f3d27 1714 TV_NONE, /* tv_id */
1715 ( PROP_ssa | PROP_cfg ), /* properties_required */
1716 0, /* properties_provided */
1717 0, /* properties_destroyed */
1718 0, /* todo_flags_start */
1719 0, /* todo_flags_finish */
1720};
1721
1722class pass_omp_simd_clone : public simple_ipa_opt_pass
1723{
1724public:
1725 pass_omp_simd_clone(gcc::context *ctxt)
1726 : simple_ipa_opt_pass(pass_data_omp_simd_clone, ctxt)
1727 {}
1728
1729 /* opt_pass methods: */
1730 virtual bool gate (function *);
1731 virtual unsigned int execute (function *) { return ipa_omp_simd_clone (); }
1732};
1733
1734bool
1735pass_omp_simd_clone::gate (function *)
1736{
1737 return targetm.simd_clone.compute_vecsize_and_simdlen != NULL;
1738}
1739
1740} // anon namespace
1741
1742simple_ipa_opt_pass *
1743make_pass_omp_simd_clone (gcc::context *ctxt)
1744{
1745 return new pass_omp_simd_clone (ctxt);
1746}
Mirror of https://gcc.gnu.org/git/gcc.git