Branch data Line data Source code
1 : : /* General types and functions that are useful for processing of OpenMP,
2 : : OpenACC and similar directives at various stages of compilation.
3 : :
4 : : Copyright (C) 2005-2024 Free Software Foundation, Inc.
5 : :
6 : : This file is part of GCC.
7 : :
8 : : GCC is free software; you can redistribute it and/or modify it under
9 : : the terms of the GNU General Public License as published by the Free
10 : : Software Foundation; either version 3, or (at your option) any later
11 : : version.
12 : :
13 : : GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14 : : WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 : : FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
16 : : for more details.
17 : :
18 : : You should have received a copy of the GNU General Public License
19 : : along with GCC; see the file COPYING3. If not see
20 : : <http://www.gnu.org/licenses/>. */
21 : :
22 : : #include "config.h"
23 : : #include "system.h"
24 : : #include "coretypes.h"
25 : : #include "backend.h"
26 : : #include "target.h"
27 : : #include "tree.h"
28 : : #include "gimple.h"
29 : : #include "ssa.h"
30 : : #include "diagnostic-core.h"
31 : : #include "fold-const.h"
32 : : #include "langhooks.h"
33 : : #include "omp-general.h"
34 : : #include "stringpool.h"
35 : : #include "attribs.h"
36 : : #include "gimplify.h"
37 : : #include "cgraph.h"
38 : : #include "alloc-pool.h"
39 : : #include "symbol-summary.h"
40 : : #include "tree-pass.h"
41 : : #include "omp-device-properties.h"
42 : : #include "tree-iterator.h"
43 : : #include "data-streamer.h"
44 : : #include "streamer-hooks.h"
45 : : #include "opts.h"
46 : : #include "tree-pretty-print.h"
47 : :
48 : : enum omp_requires omp_requires_mask;
49 : :
50 : : /* Find an OMP clause of type KIND within CLAUSES. */
51 : : tree
52 : 1168930 : omp_find_clause (tree clauses, enum omp_clause_code kind)
53 : : {
54 : 4322039 : for (; clauses ; clauses = OMP_CLAUSE_CHAIN (clauses))
55 : 3403262 : if (OMP_CLAUSE_CODE (clauses) == kind)
56 : 250153 : return clauses;
57 : :
58 : : return NULL_TREE;
59 : : }
60 : :
61 : : /* True if OpenMP should regard this DECL as being a scalar which has Fortran's
62 : : allocatable or pointer attribute. */
63 : : bool
64 : 15326 : omp_is_allocatable_or_ptr (tree decl)
65 : : {
66 : 15326 : return lang_hooks.decls.omp_is_allocatable_or_ptr (decl);
67 : : }
68 : :
69 : : /* Check whether this DECL belongs to a Fortran optional argument.
70 : : With 'for_present_check' set to false, decls which are optional parameters
71 : : themselve are returned as tree - or a NULL_TREE otherwise. Those decls are
72 : : always pointers. With 'for_present_check' set to true, the decl for checking
73 : : whether an argument is present is returned; for arguments with value
74 : : attribute this is the hidden argument and of BOOLEAN_TYPE. If the decl is
75 : : unrelated to optional arguments, NULL_TREE is returned. */
76 : :
77 : : tree
78 : 12844 : omp_check_optional_argument (tree decl, bool for_present_check)
79 : : {
80 : 12844 : return lang_hooks.decls.omp_check_optional_argument (decl, for_present_check);
81 : : }
82 : :
83 : : /* Return true if TYPE is an OpenMP mappable type. */
84 : :
85 : : bool
86 : 44505 : omp_mappable_type (tree type)
87 : : {
88 : : /* Mappable type has to be complete. */
89 : 44505 : if (type == error_mark_node || !COMPLETE_TYPE_P (type))
90 : 188 : return false;
91 : : return true;
92 : : }
93 : :
94 : : /* True if OpenMP should privatize what this DECL points to rather
95 : : than the DECL itself. */
96 : :
97 : : bool
98 : 4874892 : omp_privatize_by_reference (tree decl)
99 : : {
100 : 4874892 : return lang_hooks.decls.omp_privatize_by_reference (decl);
101 : : }
102 : :
103 : : /* Adjust *COND_CODE and *N2 so that the former is either LT_EXPR or GT_EXPR,
104 : : given that V is the loop index variable and STEP is loop step. */
105 : :
106 : : void
107 : 191940 : omp_adjust_for_condition (location_t loc, enum tree_code *cond_code, tree *n2,
108 : : tree v, tree step)
109 : : {
110 : 191940 : switch (*cond_code)
111 : : {
112 : : case LT_EXPR:
113 : : case GT_EXPR:
114 : : break;
115 : :
116 : 29865 : case NE_EXPR:
117 : 29865 : gcc_assert (TREE_CODE (step) == INTEGER_CST);
118 : 29865 : if (TREE_CODE (TREE_TYPE (v)) == INTEGER_TYPE
119 : 29865 : || TREE_CODE (TREE_TYPE (v)) == BITINT_TYPE)
120 : : {
121 : 25021 : if (integer_onep (step))
122 : 17737 : *cond_code = LT_EXPR;
123 : : else
124 : : {
125 : 7284 : gcc_assert (integer_minus_onep (step));
126 : 7284 : *cond_code = GT_EXPR;
127 : : }
128 : : }
129 : : else
130 : : {
131 : 4844 : tree unit = TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (v)));
132 : 4844 : gcc_assert (TREE_CODE (unit) == INTEGER_CST);
133 : 4844 : if (tree_int_cst_equal (unit, step))
134 : 3358 : *cond_code = LT_EXPR;
135 : : else
136 : : {
137 : 1486 : gcc_assert (wi::neg (wi::to_widest (unit))
138 : : == wi::to_widest (step));
139 : 1486 : *cond_code = GT_EXPR;
140 : : }
141 : : }
142 : :
143 : : break;
144 : :
145 : 27238 : case LE_EXPR:
146 : 27238 : if (POINTER_TYPE_P (TREE_TYPE (*n2)))
147 : : {
148 : 123 : tree unit = TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (v)));
149 : 123 : gcc_assert (TREE_CODE (unit) == INTEGER_CST);
150 : 123 : *n2 = fold_build_pointer_plus_loc (loc, *n2, unit);
151 : : }
152 : : else
153 : 27115 : *n2 = fold_build2_loc (loc, PLUS_EXPR, TREE_TYPE (*n2), *n2,
154 : 27115 : build_int_cst (TREE_TYPE (*n2), 1));
155 : 27238 : *cond_code = LT_EXPR;
156 : 27238 : break;
157 : 1808 : case GE_EXPR:
158 : 1808 : if (POINTER_TYPE_P (TREE_TYPE (*n2)))
159 : : {
160 : 137 : tree unit = TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (v)));
161 : 137 : gcc_assert (TREE_CODE (unit) == INTEGER_CST);
162 : 137 : unit = convert_to_ptrofftype_loc (loc, unit);
163 : 137 : unit = fold_build1_loc (loc, NEGATE_EXPR, TREE_TYPE (unit),
164 : : unit);
165 : 137 : *n2 = fold_build_pointer_plus_loc (loc, *n2, unit);
166 : : }
167 : : else
168 : 1671 : *n2 = fold_build2_loc (loc, MINUS_EXPR, TREE_TYPE (*n2), *n2,
169 : 1671 : build_int_cst (TREE_TYPE (*n2), 1));
170 : 1808 : *cond_code = GT_EXPR;
171 : 1808 : break;
172 : 0 : default:
173 : 0 : gcc_unreachable ();
174 : : }
175 : 191940 : }
176 : :
177 : : /* Return the looping step from INCR, extracted from the step of a gimple omp
178 : : for statement. */
179 : :
180 : : tree
181 : 190776 : omp_get_for_step_from_incr (location_t loc, tree incr)
182 : : {
183 : 190776 : tree step;
184 : 190776 : switch (TREE_CODE (incr))
185 : : {
186 : 168545 : case PLUS_EXPR:
187 : 168545 : step = TREE_OPERAND (incr, 1);
188 : 168545 : break;
189 : 16136 : case POINTER_PLUS_EXPR:
190 : 16136 : step = fold_convert (ssizetype, TREE_OPERAND (incr, 1));
191 : 16136 : break;
192 : 6095 : case MINUS_EXPR:
193 : 6095 : step = TREE_OPERAND (incr, 1);
194 : 6095 : step = fold_build1_loc (loc, NEGATE_EXPR, TREE_TYPE (step), step);
195 : 6095 : break;
196 : 0 : default:
197 : 0 : gcc_unreachable ();
198 : : }
199 : 190776 : return step;
200 : : }
201 : :
202 : : /* Extract the header elements of parallel loop FOR_STMT and store
203 : : them into *FD. */
204 : :
205 : : void
206 : 124973 : omp_extract_for_data (gomp_for *for_stmt, struct omp_for_data *fd,
207 : : struct omp_for_data_loop *loops)
208 : : {
209 : 124973 : tree t, var, *collapse_iter, *collapse_count;
210 : 124973 : tree count = NULL_TREE, iter_type = long_integer_type_node;
211 : 124973 : struct omp_for_data_loop *loop;
212 : 124973 : int i;
213 : 124973 : struct omp_for_data_loop dummy_loop;
214 : 124973 : location_t loc = gimple_location (for_stmt);
215 : 124973 : bool simd = gimple_omp_for_kind (for_stmt) == GF_OMP_FOR_KIND_SIMD;
216 : 124973 : bool distribute = gimple_omp_for_kind (for_stmt)
217 : 124973 : == GF_OMP_FOR_KIND_DISTRIBUTE;
218 : 124973 : bool taskloop = gimple_omp_for_kind (for_stmt)
219 : 124973 : == GF_OMP_FOR_KIND_TASKLOOP;
220 : 124973 : bool order_reproducible = false;
221 : 124973 : tree iterv, countv;
222 : :
223 : 124973 : fd->for_stmt = for_stmt;
224 : 124973 : fd->pre = NULL;
225 : 124973 : fd->have_nowait = distribute || simd;
226 : 124973 : fd->have_ordered = false;
227 : 124973 : fd->have_reductemp = false;
228 : 124973 : fd->have_pointer_condtemp = false;
229 : 124973 : fd->have_scantemp = false;
230 : 124973 : fd->have_nonctrl_scantemp = false;
231 : 124973 : fd->non_rect = false;
232 : 124973 : fd->lastprivate_conditional = 0;
233 : 124973 : fd->tiling = NULL_TREE;
234 : 124973 : fd->collapse = 1;
235 : 124973 : fd->ordered = 0;
236 : 124973 : fd->first_nonrect = -1;
237 : 124973 : fd->last_nonrect = -1;
238 : 124973 : fd->sched_kind = OMP_CLAUSE_SCHEDULE_STATIC;
239 : 124973 : fd->sched_modifiers = 0;
240 : 124973 : fd->chunk_size = NULL_TREE;
241 : 124973 : fd->simd_schedule = false;
242 : 124973 : fd->first_inner_iterations = NULL_TREE;
243 : 124973 : fd->factor = NULL_TREE;
244 : 124973 : fd->adjn1 = NULL_TREE;
245 : 124973 : collapse_iter = NULL;
246 : 124973 : collapse_count = NULL;
247 : :
248 : 634672 : for (t = gimple_omp_for_clauses (for_stmt); t ; t = OMP_CLAUSE_CHAIN (t))
249 : 509699 : switch (OMP_CLAUSE_CODE (t))
250 : : {
251 : 44392 : case OMP_CLAUSE_NOWAIT:
252 : 44392 : fd->have_nowait = true;
253 : 44392 : break;
254 : 1389 : case OMP_CLAUSE_ORDERED:
255 : 1389 : fd->have_ordered = true;
256 : 1389 : if (OMP_CLAUSE_ORDERED_DOACROSS (t))
257 : : {
258 : 692 : if (OMP_CLAUSE_ORDERED_EXPR (t))
259 : 672 : fd->ordered = tree_to_shwi (OMP_CLAUSE_ORDERED_EXPR (t));
260 : : else
261 : 20 : fd->ordered = -1;
262 : : }
263 : : break;
264 : 30353 : case OMP_CLAUSE_SCHEDULE:
265 : 30353 : gcc_assert (!distribute && !taskloop);
266 : 30353 : fd->sched_kind
267 : 30353 : = (enum omp_clause_schedule_kind)
268 : 30353 : (OMP_CLAUSE_SCHEDULE_KIND (t) & OMP_CLAUSE_SCHEDULE_MASK);
269 : 30353 : fd->sched_modifiers = (OMP_CLAUSE_SCHEDULE_KIND (t)
270 : 30353 : & ~OMP_CLAUSE_SCHEDULE_MASK);
271 : 30353 : fd->chunk_size = OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (t);
272 : 30353 : fd->simd_schedule = OMP_CLAUSE_SCHEDULE_SIMD (t);
273 : 30353 : break;
274 : 7004 : case OMP_CLAUSE_DIST_SCHEDULE:
275 : 7004 : gcc_assert (distribute);
276 : 7004 : fd->chunk_size = OMP_CLAUSE_DIST_SCHEDULE_CHUNK_EXPR (t);
277 : 7004 : break;
278 : 41249 : case OMP_CLAUSE_COLLAPSE:
279 : 41249 : fd->collapse = tree_to_shwi (OMP_CLAUSE_COLLAPSE_EXPR (t));
280 : 41249 : if (fd->collapse > 1)
281 : : {
282 : 33684 : collapse_iter = &OMP_CLAUSE_COLLAPSE_ITERVAR (t);
283 : 33684 : collapse_count = &OMP_CLAUSE_COLLAPSE_COUNT (t);
284 : : }
285 : : break;
286 : 338 : case OMP_CLAUSE_TILE:
287 : 338 : fd->tiling = OMP_CLAUSE_TILE_LIST (t);
288 : 338 : fd->collapse = list_length (fd->tiling);
289 : 338 : gcc_assert (fd->collapse);
290 : 338 : collapse_iter = &OMP_CLAUSE_TILE_ITERVAR (t);
291 : 338 : collapse_count = &OMP_CLAUSE_TILE_COUNT (t);
292 : 338 : break;
293 : 482 : case OMP_CLAUSE__REDUCTEMP_:
294 : 482 : fd->have_reductemp = true;
295 : 482 : break;
296 : 40518 : case OMP_CLAUSE_LASTPRIVATE:
297 : 40518 : if (OMP_CLAUSE_LASTPRIVATE_CONDITIONAL (t))
298 : 1504 : fd->lastprivate_conditional++;
299 : : break;
300 : 1556 : case OMP_CLAUSE__CONDTEMP_:
301 : 1556 : if (POINTER_TYPE_P (TREE_TYPE (OMP_CLAUSE_DECL (t))))
302 : 185 : fd->have_pointer_condtemp = true;
303 : : break;
304 : 1102 : case OMP_CLAUSE__SCANTEMP_:
305 : 1102 : fd->have_scantemp = true;
306 : 1102 : if (!OMP_CLAUSE__SCANTEMP__ALLOC (t)
307 : 1102 : && !OMP_CLAUSE__SCANTEMP__CONTROL (t))
308 : 205 : fd->have_nonctrl_scantemp = true;
309 : : break;
310 : 7544 : case OMP_CLAUSE_ORDER:
311 : : /* FIXME: For OpenMP 5.2 this should change to
312 : : if (OMP_CLAUSE_ORDER_REPRODUCIBLE (t))
313 : : (with the exception of loop construct but that lowers to
314 : : no schedule/dist_schedule clauses currently). */
315 : 7544 : if (!OMP_CLAUSE_ORDER_UNCONSTRAINED (t))
316 : 509699 : order_reproducible = true;
317 : : default:
318 : : break;
319 : : }
320 : :
321 : 124973 : if (fd->ordered == -1)
322 : 20 : fd->ordered = fd->collapse;
323 : :
324 : : /* For order(reproducible:concurrent) schedule ({dynamic,guided,runtime})
325 : : we have either the option to expensively remember at runtime how we've
326 : : distributed work from first loop and reuse that in following loops with
327 : : the same number of iterations and schedule, or just force static schedule.
328 : : OpenMP API calls etc. aren't allowed in order(concurrent) bodies so
329 : : users can't observe it easily anyway. */
330 : 124973 : if (order_reproducible)
331 : 7249 : fd->sched_kind = OMP_CLAUSE_SCHEDULE_STATIC;
332 : 124973 : if (fd->collapse > 1 || fd->tiling)
333 : 34018 : fd->loops = loops;
334 : : else
335 : 90955 : fd->loops = &fd->loop;
336 : :
337 : 124973 : if (fd->ordered && fd->collapse == 1 && loops != NULL)
338 : : {
339 : 184 : fd->loops = loops;
340 : 184 : iterv = NULL_TREE;
341 : 184 : countv = NULL_TREE;
342 : 184 : collapse_iter = &iterv;
343 : 184 : collapse_count = &countv;
344 : : }
345 : :
346 : : /* FIXME: for now map schedule(auto) to schedule(static).
347 : : There should be analysis to determine whether all iterations
348 : : are approximately the same amount of work (then schedule(static)
349 : : is best) or if it varies (then schedule(dynamic,N) is better). */
350 : 124973 : if (fd->sched_kind == OMP_CLAUSE_SCHEDULE_AUTO)
351 : : {
352 : 5747 : fd->sched_kind = OMP_CLAUSE_SCHEDULE_STATIC;
353 : 5747 : gcc_assert (fd->chunk_size == NULL);
354 : : }
355 : 124973 : gcc_assert ((fd->collapse == 1 && !fd->tiling) || collapse_iter != NULL);
356 : 124973 : if (taskloop)
357 : 9604 : fd->sched_kind = OMP_CLAUSE_SCHEDULE_RUNTIME;
358 : 124973 : if (fd->sched_kind == OMP_CLAUSE_SCHEDULE_RUNTIME)
359 : 16605 : gcc_assert (fd->chunk_size == NULL);
360 : 108368 : else if (fd->chunk_size == NULL)
361 : : {
362 : : /* We only need to compute a default chunk size for ordered
363 : : static loops and dynamic loops. */
364 : 85313 : if (fd->sched_kind != OMP_CLAUSE_SCHEDULE_STATIC
365 : 84754 : || fd->have_ordered)
366 : 1270 : fd->chunk_size = (fd->sched_kind == OMP_CLAUSE_SCHEDULE_STATIC)
367 : 1270 : ? integer_zero_node : integer_one_node;
368 : : }
369 : :
370 : 124973 : int cnt = fd->ordered ? fd->ordered : fd->collapse;
371 : 124973 : int single_nonrect = -1;
372 : 124973 : tree single_nonrect_count = NULL_TREE;
373 : 124973 : enum tree_code single_nonrect_cond_code = ERROR_MARK;
374 : 188918 : for (i = 1; i < cnt; i++)
375 : : {
376 : 64073 : tree n1 = gimple_omp_for_initial (for_stmt, i);
377 : 64073 : tree n2 = gimple_omp_for_final (for_stmt, i);
378 : 64073 : if (TREE_CODE (n1) == TREE_VEC)
379 : : {
380 : 1786 : if (fd->non_rect)
381 : : {
382 : : single_nonrect = -1;
383 : : break;
384 : : }
385 : 2152 : for (int j = i - 1; j >= 0; j--)
386 : 2152 : if (TREE_VEC_ELT (n1, 0) == gimple_omp_for_index (for_stmt, j))
387 : : {
388 : : single_nonrect = j;
389 : : break;
390 : : }
391 : 1664 : fd->non_rect = true;
392 : : }
393 : 62287 : else if (TREE_CODE (n2) == TREE_VEC)
394 : : {
395 : 531 : if (fd->non_rect)
396 : : {
397 : : single_nonrect = -1;
398 : : break;
399 : : }
400 : 681 : for (int j = i - 1; j >= 0; j--)
401 : 681 : if (TREE_VEC_ELT (n2, 0) == gimple_omp_for_index (for_stmt, j))
402 : : {
403 : : single_nonrect = j;
404 : : break;
405 : : }
406 : 525 : fd->non_rect = true;
407 : : }
408 : : }
409 : 314103 : for (i = 0; i < cnt; i++)
410 : : {
411 : 189130 : if (i == 0
412 : 124973 : && fd->collapse == 1
413 : 91127 : && !fd->tiling
414 : 90955 : && (fd->ordered == 0 || loops == NULL))
415 : 90771 : loop = &fd->loop;
416 : 98175 : else if (loops != NULL)
417 : 32574 : loop = loops + i;
418 : : else
419 : : loop = &dummy_loop;
420 : :
421 : 189130 : loop->v = gimple_omp_for_index (for_stmt, i);
422 : 189130 : gcc_assert (SSA_VAR_P (loop->v));
423 : 189130 : gcc_assert (TREE_CODE (TREE_TYPE (loop->v)) == INTEGER_TYPE
424 : : || TREE_CODE (TREE_TYPE (loop->v)) == BITINT_TYPE
425 : : || TREE_CODE (TREE_TYPE (loop->v)) == POINTER_TYPE);
426 : 189130 : var = TREE_CODE (loop->v) == SSA_NAME ? SSA_NAME_VAR (loop->v) : loop->v;
427 : 189130 : loop->n1 = gimple_omp_for_initial (for_stmt, i);
428 : 189130 : loop->m1 = NULL_TREE;
429 : 189130 : loop->m2 = NULL_TREE;
430 : 189130 : loop->outer = 0;
431 : 189130 : loop->non_rect_referenced = false;
432 : 189130 : if (TREE_CODE (loop->n1) == TREE_VEC)
433 : : {
434 : 2313 : for (int j = i - 1; j >= 0; j--)
435 : 2313 : if (TREE_VEC_ELT (loop->n1, 0) == gimple_omp_for_index (for_stmt, j))
436 : : {
437 : 1786 : loop->outer = i - j;
438 : 1786 : if (loops != NULL)
439 : 639 : loops[j].non_rect_referenced = true;
440 : 1786 : if (fd->first_nonrect == -1 || fd->first_nonrect > j)
441 : 1664 : fd->first_nonrect = j;
442 : : break;
443 : : }
444 : 1786 : gcc_assert (loop->outer);
445 : 1786 : loop->m1 = TREE_VEC_ELT (loop->n1, 1);
446 : 1786 : loop->n1 = TREE_VEC_ELT (loop->n1, 2);
447 : 1786 : fd->non_rect = true;
448 : 1786 : fd->last_nonrect = i;
449 : : }
450 : :
451 : 189130 : loop->cond_code = gimple_omp_for_cond (for_stmt, i);
452 : 189130 : loop->n2 = gimple_omp_for_final (for_stmt, i);
453 : 189130 : gcc_assert (loop->cond_code != NE_EXPR
454 : : || (gimple_omp_for_kind (for_stmt)
455 : : != GF_OMP_FOR_KIND_OACC_LOOP));
456 : 189130 : if (TREE_CODE (loop->n2) == TREE_VEC)
457 : : {
458 : 1273 : if (loop->outer)
459 : 742 : gcc_assert (TREE_VEC_ELT (loop->n2, 0)
460 : : == gimple_omp_for_index (for_stmt, i - loop->outer));
461 : : else
462 : 690 : for (int j = i - 1; j >= 0; j--)
463 : 690 : if (TREE_VEC_ELT (loop->n2, 0) == gimple_omp_for_index (for_stmt, j))
464 : : {
465 : 531 : loop->outer = i - j;
466 : 531 : if (loops != NULL)
467 : 241 : loops[j].non_rect_referenced = true;
468 : 531 : if (fd->first_nonrect == -1 || fd->first_nonrect > j)
469 : 525 : fd->first_nonrect = j;
470 : : break;
471 : : }
472 : 1273 : gcc_assert (loop->outer);
473 : 1273 : loop->m2 = TREE_VEC_ELT (loop->n2, 1);
474 : 1273 : loop->n2 = TREE_VEC_ELT (loop->n2, 2);
475 : 1273 : fd->non_rect = true;
476 : 1273 : fd->last_nonrect = i;
477 : : }
478 : :
479 : 189130 : t = gimple_omp_for_incr (for_stmt, i);
480 : 189130 : gcc_assert (TREE_OPERAND (t, 0) == var);
481 : 189130 : loop->step = omp_get_for_step_from_incr (loc, t);
482 : :
483 : 189130 : omp_adjust_for_condition (loc, &loop->cond_code, &loop->n2, loop->v,
484 : : loop->step);
485 : :
486 : 189130 : if (simd
487 : 149408 : || (fd->sched_kind == OMP_CLAUSE_SCHEDULE_STATIC
488 : 109985 : && !fd->have_ordered))
489 : : {
490 : 147996 : if (fd->collapse == 1 && !fd->tiling)
491 : 73186 : iter_type = TREE_TYPE (loop->v);
492 : 74810 : else if (i == 0
493 : 74810 : || TYPE_PRECISION (iter_type)
494 : 48313 : < TYPE_PRECISION (TREE_TYPE (loop->v)))
495 : : {
496 : 37374 : if (TREE_CODE (iter_type) == BITINT_TYPE
497 : 37374 : || TREE_CODE (TREE_TYPE (loop->v)) == BITINT_TYPE)
498 : 2 : iter_type
499 : 2 : = build_bitint_type (TYPE_PRECISION (TREE_TYPE (loop->v)),
500 : : 1);
501 : : else
502 : 37372 : iter_type
503 : : = build_nonstandard_integer_type
504 : 37372 : (TYPE_PRECISION (TREE_TYPE (loop->v)), 1);
505 : : }
506 : : }
507 : 41134 : else if (iter_type != long_long_unsigned_type_node)
508 : : {
509 : 37674 : if (POINTER_TYPE_P (TREE_TYPE (loop->v)))
510 : : iter_type = long_long_unsigned_type_node;
511 : 35712 : else if (TYPE_UNSIGNED (TREE_TYPE (loop->v))
512 : 35712 : && TYPE_PRECISION (TREE_TYPE (loop->v))
513 : 6284 : >= TYPE_PRECISION (iter_type))
514 : : {
515 : 2318 : tree n;
516 : :
517 : 2318 : if (loop->cond_code == LT_EXPR)
518 : 450 : n = fold_build2_loc (loc, PLUS_EXPR, TREE_TYPE (loop->v),
519 : : loop->n2, loop->step);
520 : : else
521 : 1868 : n = loop->n1;
522 : 2318 : if (loop->m1
523 : 2318 : || loop->m2
524 : 2318 : || TREE_CODE (n) != INTEGER_CST
525 : 4282 : || tree_int_cst_lt (TYPE_MAX_VALUE (iter_type), n))
526 : 2242 : iter_type = long_long_unsigned_type_node;
527 : : }
528 : 33394 : else if (TYPE_PRECISION (TREE_TYPE (loop->v))
529 : 33394 : > TYPE_PRECISION (iter_type))
530 : : {
531 : 0 : tree n1, n2;
532 : :
533 : 0 : if (loop->cond_code == LT_EXPR)
534 : : {
535 : 0 : n1 = loop->n1;
536 : 0 : n2 = fold_build2_loc (loc, PLUS_EXPR, TREE_TYPE (loop->v),
537 : : loop->n2, loop->step);
538 : : }
539 : : else
540 : : {
541 : 0 : n1 = fold_build2_loc (loc, MINUS_EXPR, TREE_TYPE (loop->v),
542 : : loop->n2, loop->step);
543 : 0 : n2 = loop->n1;
544 : : }
545 : 0 : if (loop->m1
546 : 0 : || loop->m2
547 : 0 : || TREE_CODE (n1) != INTEGER_CST
548 : 0 : || TREE_CODE (n2) != INTEGER_CST
549 : 0 : || !tree_int_cst_lt (TYPE_MIN_VALUE (iter_type), n1)
550 : 0 : || !tree_int_cst_lt (n2, TYPE_MAX_VALUE (iter_type)))
551 : 0 : iter_type = long_long_unsigned_type_node;
552 : : }
553 : : }
554 : :
555 : 189130 : if (i >= fd->collapse)
556 : 1802 : continue;
557 : :
558 : 187328 : if (collapse_count && *collapse_count == NULL)
559 : : {
560 : 31749 : if (count && integer_zerop (count))
561 : 2240 : continue;
562 : 29509 : tree n1first = NULL_TREE, n2first = NULL_TREE;
563 : 29509 : tree n1last = NULL_TREE, n2last = NULL_TREE;
564 : 29509 : tree ostep = NULL_TREE;
565 : 29509 : if (loop->m1 || loop->m2)
566 : : {
567 : 911 : if (count == NULL_TREE)
568 : 645 : continue;
569 : 266 : if (single_nonrect == -1
570 : 247 : || (loop->m1 && TREE_CODE (loop->m1) != INTEGER_CST)
571 : 206 : || (loop->m2 && TREE_CODE (loop->m2) != INTEGER_CST)
572 : 190 : || TREE_CODE (loop->n1) != INTEGER_CST
573 : 186 : || TREE_CODE (loop->n2) != INTEGER_CST
574 : 182 : || TREE_CODE (loop->step) != INTEGER_CST)
575 : : {
576 : 84 : count = NULL_TREE;
577 : 84 : continue;
578 : : }
579 : 182 : tree var = gimple_omp_for_initial (for_stmt, single_nonrect);
580 : 182 : tree itype = TREE_TYPE (var);
581 : 182 : tree first = gimple_omp_for_initial (for_stmt, single_nonrect);
582 : 182 : t = gimple_omp_for_incr (for_stmt, single_nonrect);
583 : 182 : ostep = omp_get_for_step_from_incr (loc, t);
584 : 182 : t = fold_binary (MINUS_EXPR, long_long_unsigned_type_node,
585 : : single_nonrect_count,
586 : : build_one_cst (long_long_unsigned_type_node));
587 : 182 : t = fold_convert (itype, t);
588 : 182 : first = fold_convert (itype, first);
589 : 182 : ostep = fold_convert (itype, ostep);
590 : 182 : tree last = fold_binary (PLUS_EXPR, itype, first,
591 : : fold_binary (MULT_EXPR, itype, t,
592 : : ostep));
593 : 182 : if (TREE_CODE (first) != INTEGER_CST
594 : 182 : || TREE_CODE (last) != INTEGER_CST)
595 : : {
596 : 0 : count = NULL_TREE;
597 : 0 : continue;
598 : : }
599 : 182 : if (loop->m1)
600 : : {
601 : 115 : tree m1 = fold_convert (itype, loop->m1);
602 : 115 : tree n1 = fold_convert (itype, loop->n1);
603 : 115 : n1first = fold_binary (PLUS_EXPR, itype,
604 : : fold_binary (MULT_EXPR, itype,
605 : : first, m1), n1);
606 : 115 : n1last = fold_binary (PLUS_EXPR, itype,
607 : : fold_binary (MULT_EXPR, itype,
608 : : last, m1), n1);
609 : : }
610 : : else
611 : 67 : n1first = n1last = loop->n1;
612 : 182 : if (loop->m2)
613 : : {
614 : 136 : tree n2 = fold_convert (itype, loop->n2);
615 : 136 : tree m2 = fold_convert (itype, loop->m2);
616 : 136 : n2first = fold_binary (PLUS_EXPR, itype,
617 : : fold_binary (MULT_EXPR, itype,
618 : : first, m2), n2);
619 : 136 : n2last = fold_binary (PLUS_EXPR, itype,
620 : : fold_binary (MULT_EXPR, itype,
621 : : last, m2), n2);
622 : : }
623 : : else
624 : 46 : n2first = n2last = loop->n2;
625 : 182 : n1first = fold_convert (TREE_TYPE (loop->v), n1first);
626 : 182 : n2first = fold_convert (TREE_TYPE (loop->v), n2first);
627 : 182 : n1last = fold_convert (TREE_TYPE (loop->v), n1last);
628 : 182 : n2last = fold_convert (TREE_TYPE (loop->v), n2last);
629 : 182 : t = fold_binary (loop->cond_code, boolean_type_node,
630 : : n1first, n2first);
631 : 182 : tree t2 = fold_binary (loop->cond_code, boolean_type_node,
632 : : n1last, n2last);
633 : 182 : if (t && t2 && integer_nonzerop (t) && integer_nonzerop (t2))
634 : : /* All outer loop iterators have at least one inner loop
635 : : iteration. Try to compute the count at compile time. */
636 : : t = NULL_TREE;
637 : 103 : else if (t && t2 && integer_zerop (t) && integer_zerop (t2))
638 : : /* No iterations of the inner loop. count will be set to
639 : : zero cst below. */;
640 : 95 : else if (TYPE_UNSIGNED (itype)
641 : 95 : || t == NULL_TREE
642 : 95 : || t2 == NULL_TREE
643 : 95 : || TREE_CODE (t) != INTEGER_CST
644 : 190 : || TREE_CODE (t2) != INTEGER_CST)
645 : : {
646 : : /* Punt (for now). */
647 : 0 : count = NULL_TREE;
648 : 0 : continue;
649 : : }
650 : : else
651 : : {
652 : : /* Some iterations of the outer loop have zero iterations
653 : : of the inner loop, while others have at least one.
654 : : In this case, we need to adjust one of those outer
655 : : loop bounds. If ADJ_FIRST, we need to adjust outer n1
656 : : (first), otherwise outer n2 (last). */
657 : 95 : bool adj_first = integer_zerop (t);
658 : 95 : tree n1 = fold_convert (itype, loop->n1);
659 : 95 : tree n2 = fold_convert (itype, loop->n2);
660 : 95 : tree m1 = loop->m1 ? fold_convert (itype, loop->m1)
661 : 25 : : build_zero_cst (itype);
662 : 95 : tree m2 = loop->m2 ? fold_convert (itype, loop->m2)
663 : 11 : : build_zero_cst (itype);
664 : 95 : t = fold_binary (MINUS_EXPR, itype, n1, n2);
665 : 95 : t2 = fold_binary (MINUS_EXPR, itype, m2, m1);
666 : 95 : t = fold_binary (TRUNC_DIV_EXPR, itype, t, t2);
667 : 95 : t2 = fold_binary (MINUS_EXPR, itype, t, first);
668 : 95 : t2 = fold_binary (TRUNC_MOD_EXPR, itype, t2, ostep);
669 : 95 : t = fold_binary (MINUS_EXPR, itype, t, t2);
670 : 95 : tree n1cur
671 : 95 : = fold_binary (PLUS_EXPR, itype, n1,
672 : : fold_binary (MULT_EXPR, itype, m1, t));
673 : 95 : tree n2cur
674 : 95 : = fold_binary (PLUS_EXPR, itype, n2,
675 : : fold_binary (MULT_EXPR, itype, m2, t));
676 : 95 : t2 = fold_binary (loop->cond_code, boolean_type_node,
677 : : n1cur, n2cur);
678 : 95 : tree t3 = fold_binary (MULT_EXPR, itype, m1, ostep);
679 : 95 : tree t4 = fold_binary (MULT_EXPR, itype, m2, ostep);
680 : 95 : tree diff;
681 : 95 : if (adj_first)
682 : : {
683 : 67 : tree new_first;
684 : 67 : if (integer_nonzerop (t2))
685 : : {
686 : 6 : new_first = t;
687 : 6 : n1first = n1cur;
688 : 6 : n2first = n2cur;
689 : 6 : if (flag_checking)
690 : : {
691 : 6 : t3 = fold_binary (MINUS_EXPR, itype, n1cur, t3);
692 : 6 : t4 = fold_binary (MINUS_EXPR, itype, n2cur, t4);
693 : 6 : t3 = fold_binary (loop->cond_code,
694 : : boolean_type_node, t3, t4);
695 : 6 : gcc_assert (integer_zerop (t3));
696 : : }
697 : : }
698 : : else
699 : : {
700 : 61 : t3 = fold_binary (PLUS_EXPR, itype, n1cur, t3);
701 : 61 : t4 = fold_binary (PLUS_EXPR, itype, n2cur, t4);
702 : 61 : new_first = fold_binary (PLUS_EXPR, itype, t, ostep);
703 : 61 : n1first = t3;
704 : 61 : n2first = t4;
705 : 61 : if (flag_checking)
706 : : {
707 : 61 : t3 = fold_binary (loop->cond_code,
708 : : boolean_type_node, t3, t4);
709 : 61 : gcc_assert (integer_nonzerop (t3));
710 : : }
711 : : }
712 : 67 : diff = fold_binary (MINUS_EXPR, itype, new_first, first);
713 : 67 : first = new_first;
714 : 67 : fd->adjn1 = first;
715 : : }
716 : : else
717 : : {
718 : 28 : tree new_last;
719 : 28 : if (integer_zerop (t2))
720 : : {
721 : 11 : t3 = fold_binary (MINUS_EXPR, itype, n1cur, t3);
722 : 11 : t4 = fold_binary (MINUS_EXPR, itype, n2cur, t4);
723 : 11 : new_last = fold_binary (MINUS_EXPR, itype, t, ostep);
724 : 11 : n1last = t3;
725 : 11 : n2last = t4;
726 : 11 : if (flag_checking)
727 : : {
728 : 11 : t3 = fold_binary (loop->cond_code,
729 : : boolean_type_node, t3, t4);
730 : 11 : gcc_assert (integer_nonzerop (t3));
731 : : }
732 : : }
733 : : else
734 : : {
735 : 17 : new_last = t;
736 : 17 : n1last = n1cur;
737 : 17 : n2last = n2cur;
738 : 17 : if (flag_checking)
739 : : {
740 : 17 : t3 = fold_binary (PLUS_EXPR, itype, n1cur, t3);
741 : 17 : t4 = fold_binary (PLUS_EXPR, itype, n2cur, t4);
742 : 17 : t3 = fold_binary (loop->cond_code,
743 : : boolean_type_node, t3, t4);
744 : 17 : gcc_assert (integer_zerop (t3));
745 : : }
746 : : }
747 : 28 : diff = fold_binary (MINUS_EXPR, itype, last, new_last);
748 : : }
749 : 95 : if (TYPE_UNSIGNED (itype)
750 : 95 : && single_nonrect_cond_code == GT_EXPR)
751 : 0 : diff = fold_binary (TRUNC_DIV_EXPR, itype,
752 : : fold_unary (NEGATE_EXPR, itype, diff),
753 : : fold_unary (NEGATE_EXPR, itype,
754 : : ostep));
755 : : else
756 : 95 : diff = fold_binary (TRUNC_DIV_EXPR, itype, diff, ostep);
757 : 95 : diff = fold_convert (long_long_unsigned_type_node, diff);
758 : 95 : single_nonrect_count
759 : 95 : = fold_binary (MINUS_EXPR, long_long_unsigned_type_node,
760 : : single_nonrect_count, diff);
761 : 95 : t = NULL_TREE;
762 : : }
763 : : }
764 : : else
765 : 28598 : t = fold_binary (loop->cond_code, boolean_type_node,
766 : : fold_convert (TREE_TYPE (loop->v), loop->n1),
767 : : fold_convert (TREE_TYPE (loop->v), loop->n2));
768 : 28780 : if (t && integer_zerop (t))
769 : 2248 : count = build_zero_cst (long_long_unsigned_type_node);
770 : 26532 : else if ((i == 0 || count != NULL_TREE)
771 : 16843 : && (TREE_CODE (TREE_TYPE (loop->v)) == INTEGER_TYPE
772 : 1202 : || TREE_CODE (TREE_TYPE (loop->v)) == BITINT_TYPE)
773 : 15642 : && TREE_CONSTANT (loop->n1)
774 : 11641 : && TREE_CONSTANT (loop->n2)
775 : 37188 : && TREE_CODE (loop->step) == INTEGER_CST)
776 : : {
777 : 10634 : tree itype = TREE_TYPE (loop->v);
778 : :
779 : 10634 : if (POINTER_TYPE_P (itype))
780 : 0 : itype = signed_type_for (itype);
781 : 13002 : t = build_int_cst (itype, (loop->cond_code == LT_EXPR ? -1 : 1));
782 : 10634 : t = fold_build2 (PLUS_EXPR, itype,
783 : : fold_convert (itype, loop->step), t);
784 : 10634 : tree n1 = loop->n1;
785 : 10634 : tree n2 = loop->n2;
786 : 10634 : if (loop->m1 || loop->m2)
787 : : {
788 : 174 : gcc_assert (single_nonrect != -1);
789 : : n1 = n1first;
790 : : n2 = n2first;
791 : : }
792 : 10634 : t = fold_build2 (PLUS_EXPR, itype, t, fold_convert (itype, n2));
793 : 10634 : t = fold_build2 (MINUS_EXPR, itype, t, fold_convert (itype, n1));
794 : 10634 : tree step = fold_convert_loc (loc, itype, loop->step);
795 : 10634 : if (TYPE_UNSIGNED (itype) && loop->cond_code == GT_EXPR)
796 : 2254 : t = fold_build2 (TRUNC_DIV_EXPR, itype,
797 : : fold_build1 (NEGATE_EXPR, itype, t),
798 : : fold_build1 (NEGATE_EXPR, itype, step));
799 : : else
800 : 8380 : t = fold_build2 (TRUNC_DIV_EXPR, itype, t, step);
801 : 10634 : tree llutype = long_long_unsigned_type_node;
802 : 10634 : t = fold_convert (llutype, t);
803 : 10634 : if (loop->m1 || loop->m2)
804 : : {
805 : : /* t is number of iterations of inner loop at either first
806 : : or last value of the outer iterator (the one with fewer
807 : : iterations).
808 : : Compute t2 = ((m2 - m1) * ostep) / step
809 : : and niters = outer_count * t
810 : : + t2 * ((outer_count - 1) * outer_count / 2)
811 : : */
812 : 174 : tree m1 = loop->m1 ? loop->m1 : integer_zero_node;
813 : 174 : tree m2 = loop->m2 ? loop->m2 : integer_zero_node;
814 : 174 : m1 = fold_convert (itype, m1);
815 : 174 : m2 = fold_convert (itype, m2);
816 : 174 : tree t2 = fold_build2 (MINUS_EXPR, itype, m2, m1);
817 : 174 : t2 = fold_build2 (MULT_EXPR, itype, t2, ostep);
818 : 174 : if (TYPE_UNSIGNED (itype) && loop->cond_code == GT_EXPR)
819 : 0 : t2 = fold_build2 (TRUNC_DIV_EXPR, itype,
820 : : fold_build1 (NEGATE_EXPR, itype, t2),
821 : : fold_build1 (NEGATE_EXPR, itype, step));
822 : : else
823 : 174 : t2 = fold_build2 (TRUNC_DIV_EXPR, itype, t2, step);
824 : 174 : t2 = fold_convert (llutype, t2);
825 : 174 : fd->first_inner_iterations = t;
826 : 174 : fd->factor = t2;
827 : 174 : t = fold_build2 (MULT_EXPR, llutype, t,
828 : : single_nonrect_count);
829 : 174 : tree t3 = fold_build2 (MINUS_EXPR, llutype,
830 : : single_nonrect_count,
831 : : build_one_cst (llutype));
832 : 174 : t3 = fold_build2 (MULT_EXPR, llutype, t3,
833 : : single_nonrect_count);
834 : 174 : t3 = fold_build2 (TRUNC_DIV_EXPR, llutype, t3,
835 : : build_int_cst (llutype, 2));
836 : 174 : t2 = fold_build2 (MULT_EXPR, llutype, t2, t3);
837 : 174 : t = fold_build2 (PLUS_EXPR, llutype, t, t2);
838 : : }
839 : 10634 : if (i == single_nonrect)
840 : : {
841 : 247 : if (integer_zerop (t) || TREE_CODE (t) != INTEGER_CST)
842 : : count = t;
843 : : else
844 : : {
845 : 247 : single_nonrect_count = t;
846 : 247 : single_nonrect_cond_code = loop->cond_code;
847 : 247 : if (count == NULL_TREE)
848 : 246 : count = build_one_cst (llutype);
849 : : }
850 : : }
851 : 10387 : else if (count != NULL_TREE)
852 : 4144 : count = fold_build2 (MULT_EXPR, llutype, count, t);
853 : : else
854 : : count = t;
855 : 10634 : if (TREE_CODE (count) != INTEGER_CST)
856 : 0 : count = NULL_TREE;
857 : : }
858 : 15898 : else if (count && !integer_zerop (count))
859 : : count = NULL_TREE;
860 : : }
861 : : }
862 : :
863 : 124973 : if (count
864 : 124973 : && !simd
865 : 3989 : && (fd->sched_kind != OMP_CLAUSE_SCHEDULE_STATIC
866 : 3230 : || fd->have_ordered))
867 : : {
868 : 855 : if (!tree_int_cst_lt (count, TYPE_MAX_VALUE (long_integer_type_node)))
869 : 0 : iter_type = long_long_unsigned_type_node;
870 : : else
871 : 855 : iter_type = long_integer_type_node;
872 : : }
873 : 124118 : else if (collapse_iter && *collapse_iter != NULL)
874 : 22753 : iter_type = TREE_TYPE (*collapse_iter);
875 : 124973 : fd->iter_type = iter_type;
876 : 124973 : if (collapse_iter && *collapse_iter == NULL)
877 : 11453 : *collapse_iter = create_tmp_var (iter_type, ".iter");
878 : 124973 : if (collapse_count && *collapse_count == NULL)
879 : : {
880 : 11453 : if (count)
881 : : {
882 : 5160 : *collapse_count = fold_convert_loc (loc, iter_type, count);
883 : 5160 : if (fd->first_inner_iterations && fd->factor)
884 : : {
885 : 174 : t = make_tree_vec (4);
886 : 174 : TREE_VEC_ELT (t, 0) = *collapse_count;
887 : 174 : TREE_VEC_ELT (t, 1) = fd->first_inner_iterations;
888 : 174 : TREE_VEC_ELT (t, 2) = fd->factor;
889 : 174 : TREE_VEC_ELT (t, 3) = fd->adjn1;
890 : 174 : *collapse_count = t;
891 : : }
892 : : }
893 : : else
894 : 6293 : *collapse_count = create_tmp_var (iter_type, ".count");
895 : : }
896 : :
897 : 124973 : if (fd->collapse > 1 || fd->tiling || (fd->ordered && loops))
898 : : {
899 : 34202 : fd->loop.v = *collapse_iter;
900 : 34202 : fd->loop.n1 = build_int_cst (TREE_TYPE (fd->loop.v), 0);
901 : 34202 : fd->loop.n2 = *collapse_count;
902 : 34202 : if (TREE_CODE (fd->loop.n2) == TREE_VEC)
903 : : {
904 : 377 : gcc_assert (fd->non_rect);
905 : 377 : fd->first_inner_iterations = TREE_VEC_ELT (fd->loop.n2, 1);
906 : 377 : fd->factor = TREE_VEC_ELT (fd->loop.n2, 2);
907 : 377 : fd->adjn1 = TREE_VEC_ELT (fd->loop.n2, 3);
908 : 377 : fd->loop.n2 = TREE_VEC_ELT (fd->loop.n2, 0);
909 : : }
910 : 34202 : fd->loop.step = build_int_cst (TREE_TYPE (fd->loop.v), 1);
911 : 34202 : fd->loop.m1 = NULL_TREE;
912 : 34202 : fd->loop.m2 = NULL_TREE;
913 : 34202 : fd->loop.outer = 0;
914 : 34202 : fd->loop.cond_code = LT_EXPR;
915 : : }
916 : 90559 : else if (loops)
917 : 34112 : loops[0] = fd->loop;
918 : 124973 : }
919 : :
920 : : /* Build a call to GOMP_barrier. */
921 : :
922 : : gimple *
923 : 4701 : omp_build_barrier (tree lhs)
924 : : {
925 : 9344 : tree fndecl = builtin_decl_explicit (lhs ? BUILT_IN_GOMP_BARRIER_CANCEL
926 : : : BUILT_IN_GOMP_BARRIER);
927 : 4701 : gcall *g = gimple_build_call (fndecl, 0);
928 : 4701 : if (lhs)
929 : 58 : gimple_call_set_lhs (g, lhs);
930 : 4701 : return g;
931 : : }
932 : :
933 : : /* Find OMP_FOR resp. OMP_SIMD with non-NULL OMP_FOR_INIT. Also, fill in pdata
934 : : array, pdata[0] non-NULL if there is anything non-trivial in between,
935 : : pdata[1] is address of OMP_PARALLEL in between if any, pdata[2] is address
936 : : of OMP_FOR in between if any and pdata[3] is address of the inner
937 : : OMP_FOR/OMP_SIMD. */
938 : :
939 : : tree
940 : 109150 : find_combined_omp_for (tree *tp, int *walk_subtrees, void *data)
941 : : {
942 : 109150 : tree **pdata = (tree **) data;
943 : 109150 : *walk_subtrees = 0;
944 : 109150 : switch (TREE_CODE (*tp))
945 : : {
946 : 11794 : case OMP_FOR:
947 : 11794 : if (OMP_FOR_INIT (*tp) != NULL_TREE)
948 : : {
949 : 5986 : pdata[3] = tp;
950 : 5986 : return *tp;
951 : : }
952 : 5808 : pdata[2] = tp;
953 : 5808 : *walk_subtrees = 1;
954 : 5808 : break;
955 : 15263 : case OMP_SIMD:
956 : 15263 : if (OMP_FOR_INIT (*tp) != NULL_TREE)
957 : : {
958 : 15263 : pdata[3] = tp;
959 : 15263 : return *tp;
960 : : }
961 : : break;
962 : 46222 : case BIND_EXPR:
963 : 46222 : if (BIND_EXPR_VARS (*tp)
964 : 46222 : || (BIND_EXPR_BLOCK (*tp)
965 : 40697 : && BLOCK_VARS (BIND_EXPR_BLOCK (*tp))))
966 : 5087 : pdata[0] = tp;
967 : 46222 : *walk_subtrees = 1;
968 : 46222 : break;
969 : 8500 : case STATEMENT_LIST:
970 : 8500 : if (!tsi_one_before_end_p (tsi_start (*tp)))
971 : 242 : pdata[0] = tp;
972 : 8500 : *walk_subtrees = 1;
973 : 8500 : break;
974 : 218 : case TRY_FINALLY_EXPR:
975 : 218 : case CLEANUP_POINT_EXPR:
976 : 218 : pdata[0] = tp;
977 : 218 : *walk_subtrees = 1;
978 : 218 : break;
979 : 11822 : case OMP_PARALLEL:
980 : 11822 : pdata[1] = tp;
981 : 11822 : *walk_subtrees = 1;
982 : 11822 : break;
983 : : default:
984 : : break;
985 : : }
986 : : return NULL_TREE;
987 : : }
988 : :
989 : : /* Return maximum possible vectorization factor for the target. */
990 : :
991 : : poly_uint64
992 : 29396 : omp_max_vf (void)
993 : : {
994 : 29396 : if (!optimize
995 : 28069 : || optimize_debug
996 : 28069 : || !flag_tree_loop_optimize
997 : 28068 : || (!flag_tree_loop_vectorize
998 : 576 : && OPTION_SET_P (flag_tree_loop_vectorize)))
999 : 1332 : return 1;
1000 : :
1001 : 28064 : auto_vector_modes modes;
1002 : 28064 : targetm.vectorize.autovectorize_vector_modes (&modes, true);
1003 : 28064 : if (!modes.is_empty ())
1004 : : {
1005 : : poly_uint64 vf = 0;
1006 : 117103 : for (unsigned int i = 0; i < modes.length (); ++i)
1007 : : /* The returned modes use the smallest element size (and thus
1008 : : the largest nunits) for the vectorization approach that they
1009 : : represent. */
1010 : 178086 : vf = ordered_max (vf, GET_MODE_NUNITS (modes[i]));
1011 : 28060 : return vf;
1012 : : }
1013 : :
1014 : 4 : machine_mode vqimode = targetm.vectorize.preferred_simd_mode (QImode);
1015 : 4 : if (GET_MODE_CLASS (vqimode) == MODE_VECTOR_INT)
1016 : 0 : return GET_MODE_NUNITS (vqimode);
1017 : :
1018 : 4 : return 1;
1019 : 28064 : }
1020 : :
1021 : : /* Return maximum SIMT width if offloading may target SIMT hardware. */
1022 : :
1023 : : int
1024 : 3624 : omp_max_simt_vf (void)
1025 : : {
1026 : 3624 : if (!optimize)
1027 : : return 0;
1028 : : if (ENABLE_OFFLOADING)
1029 : : for (const char *c = getenv ("OFFLOAD_TARGET_NAMES"); c;)
1030 : : {
1031 : : if (startswith (c, "nvptx"))
1032 : : return 32;
1033 : : else if ((c = strchr (c, ':')))
1034 : : c++;
1035 : : }
1036 : : return 0;
1037 : : }
1038 : :
1039 : : /* Store the construct selectors as tree codes from last to first.
1040 : : CTX is a list of trait selectors, nconstructs must be equal to its
1041 : : length, and the array CONSTRUCTS holds the output. */
1042 : :
1043 : : void
1044 : 338 : omp_construct_traits_to_codes (tree ctx, int nconstructs,
1045 : : enum tree_code *constructs)
1046 : : {
1047 : 338 : int i = nconstructs - 1;
1048 : :
1049 : : /* Order must match the OMP_TRAIT_CONSTRUCT_* enumerators in
1050 : : enum omp_ts_code. */
1051 : 338 : static enum tree_code code_map[]
1052 : : = { OMP_TARGET, OMP_TEAMS, OMP_PARALLEL, OMP_FOR, OMP_SIMD };
1053 : :
1054 : 981 : for (tree ts = ctx; ts; ts = TREE_CHAIN (ts), i--)
1055 : : {
1056 : 643 : enum omp_ts_code sel = OMP_TS_CODE (ts);
1057 : 643 : int j = (int)sel - (int)OMP_TRAIT_CONSTRUCT_TARGET;
1058 : 643 : gcc_assert (j >= 0 && (unsigned int) j < ARRAY_SIZE (code_map));
1059 : 643 : constructs[i] = code_map[j];
1060 : : }
1061 : 338 : gcc_assert (i == -1);
1062 : 338 : }
1063 : :
1064 : : /* Return true if PROP is possibly present in one of the offloading target's
1065 : : OpenMP contexts. The format of PROPS string is always offloading target's
1066 : : name terminated by '\0', followed by properties for that offloading
1067 : : target separated by '\0' and terminated by another '\0'. The strings
1068 : : are created from omp-device-properties installed files of all configured
1069 : : offloading targets. */
1070 : :
1071 : : static bool
1072 : 0 : omp_offload_device_kind_arch_isa (const char *props, const char *prop)
1073 : : {
1074 : 0 : const char *names = getenv ("OFFLOAD_TARGET_NAMES");
1075 : 0 : if (names == NULL || *names == '\0')
1076 : : return false;
1077 : 0 : while (*props != '\0')
1078 : : {
1079 : 0 : size_t name_len = strlen (props);
1080 : 0 : bool matches = false;
1081 : 0 : for (const char *c = names; c; )
1082 : : {
1083 : 0 : if (strncmp (props, c, name_len) == 0
1084 : 0 : && (c[name_len] == '\0'
1085 : : || c[name_len] == ':'
1086 : : || c[name_len] == '='))
1087 : : {
1088 : : matches = true;
1089 : : break;
1090 : : }
1091 : 0 : else if ((c = strchr (c, ':')))
1092 : 0 : c++;
1093 : : }
1094 : 0 : props = props + name_len + 1;
1095 : 0 : while (*props != '\0')
1096 : : {
1097 : 0 : if (matches && strcmp (props, prop) == 0)
1098 : : return true;
1099 : 0 : props = strchr (props, '\0') + 1;
1100 : : }
1101 : 0 : props++;
1102 : : }
1103 : : return false;
1104 : : }
1105 : :
1106 : : /* Return true if the current code location is or might be offloaded.
1107 : : Return true in declare target functions, or when nested in a target
1108 : : region or when unsure, return false otherwise. */
1109 : :
1110 : : static bool
1111 : 0 : omp_maybe_offloaded (void)
1112 : : {
1113 : 0 : if (!ENABLE_OFFLOADING)
1114 : 0 : return false;
1115 : : const char *names = getenv ("OFFLOAD_TARGET_NAMES");
1116 : : if (names == NULL || *names == '\0')
1117 : : return false;
1118 : :
1119 : : if (symtab->state == PARSING)
1120 : : /* Maybe. */
1121 : : return true;
1122 : : if (cfun && cfun->after_inlining)
1123 : : return false;
1124 : : if (current_function_decl
1125 : : && lookup_attribute ("omp declare target",
1126 : : DECL_ATTRIBUTES (current_function_decl)))
1127 : : return true;
1128 : : if (cfun && (cfun->curr_properties & PROP_gimple_any) == 0)
1129 : : {
1130 : : enum tree_code construct = OMP_TARGET;
1131 : : if (omp_construct_selector_matches (&construct, 1, NULL))
1132 : : return true;
1133 : : }
1134 : : return false;
1135 : : }
1136 : :
1137 : : /* Lookup tables for context selectors. */
1138 : : const char *omp_tss_map[] =
1139 : : {
1140 : : "construct",
1141 : : "device",
1142 : : "target_device",
1143 : : "implementation",
1144 : : "user",
1145 : : NULL
1146 : : };
1147 : :
1148 : : /* Arrays of property candidates must be null-terminated. */
1149 : : static const char *const kind_properties[] =
1150 : : { "host", "nohost", "cpu", "gpu", "fpga", "any", NULL };
1151 : : static const char *const vendor_properties[] =
1152 : : { "amd", "arm", "bsc", "cray", "fujitsu", "gnu", "hpe", "ibm", "intel",
1153 : : "llvm", "nvidia", "pgi", "ti", "unknown", NULL };
1154 : : static const char *const extension_properties[] =
1155 : : { NULL };
1156 : : static const char *const atomic_default_mem_order_properties[] =
1157 : : { "seq_cst", "relaxed", "acq_rel", "acquire", "release", NULL };
1158 : :
1159 : : struct omp_ts_info omp_ts_map[] =
1160 : : {
1161 : : { "kind",
1162 : : (1 << OMP_TRAIT_SET_DEVICE) | (1 << OMP_TRAIT_SET_TARGET_DEVICE),
1163 : : OMP_TRAIT_PROPERTY_NAME_LIST, false,
1164 : : kind_properties
1165 : : },
1166 : : { "isa",
1167 : : (1 << OMP_TRAIT_SET_DEVICE) | (1 << OMP_TRAIT_SET_TARGET_DEVICE),
1168 : : OMP_TRAIT_PROPERTY_NAME_LIST, false,
1169 : : NULL
1170 : : },
1171 : : { "arch",
1172 : : (1 << OMP_TRAIT_SET_DEVICE) | (1 << OMP_TRAIT_SET_TARGET_DEVICE),
1173 : : OMP_TRAIT_PROPERTY_NAME_LIST, false,
1174 : : NULL
1175 : : },
1176 : : { "device_num",
1177 : : (1 << OMP_TRAIT_SET_TARGET_DEVICE),
1178 : : OMP_TRAIT_PROPERTY_DEV_NUM_EXPR, false,
1179 : : NULL
1180 : : },
1181 : : { "vendor",
1182 : : (1 << OMP_TRAIT_SET_IMPLEMENTATION),
1183 : : OMP_TRAIT_PROPERTY_NAME_LIST, true,
1184 : : vendor_properties,
1185 : : },
1186 : : { "extension",
1187 : : (1 << OMP_TRAIT_SET_IMPLEMENTATION),
1188 : : OMP_TRAIT_PROPERTY_NAME_LIST, true,
1189 : : extension_properties,
1190 : : },
1191 : : { "atomic_default_mem_order",
1192 : : (1 << OMP_TRAIT_SET_IMPLEMENTATION),
1193 : : OMP_TRAIT_PROPERTY_ID, true,
1194 : : atomic_default_mem_order_properties,
1195 : : },
1196 : : { "requires",
1197 : : (1 << OMP_TRAIT_SET_IMPLEMENTATION),
1198 : : OMP_TRAIT_PROPERTY_CLAUSE_LIST, true,
1199 : : NULL
1200 : : },
1201 : : { "unified_address",
1202 : : (1 << OMP_TRAIT_SET_IMPLEMENTATION),
1203 : : OMP_TRAIT_PROPERTY_NONE, true,
1204 : : NULL
1205 : : },
1206 : : { "unified_shared_memory",
1207 : : (1 << OMP_TRAIT_SET_IMPLEMENTATION),
1208 : : OMP_TRAIT_PROPERTY_NONE, true,
1209 : : NULL
1210 : : },
1211 : : { "self_maps",
1212 : : (1 << OMP_TRAIT_SET_IMPLEMENTATION),
1213 : : OMP_TRAIT_PROPERTY_NONE, true,
1214 : : NULL
1215 : : },
1216 : : { "dynamic_allocators",
1217 : : (1 << OMP_TRAIT_SET_IMPLEMENTATION),
1218 : : OMP_TRAIT_PROPERTY_NONE, true,
1219 : : NULL
1220 : : },
1221 : : { "reverse_offload",
1222 : : (1 << OMP_TRAIT_SET_IMPLEMENTATION),
1223 : : OMP_TRAIT_PROPERTY_NONE, true,
1224 : : NULL
1225 : : },
1226 : : { "condition",
1227 : : (1 << OMP_TRAIT_SET_USER),
1228 : : OMP_TRAIT_PROPERTY_BOOL_EXPR, true,
1229 : : NULL
1230 : : },
1231 : : { "target",
1232 : : (1 << OMP_TRAIT_SET_CONSTRUCT),
1233 : : OMP_TRAIT_PROPERTY_NONE, false,
1234 : : NULL
1235 : : },
1236 : : { "teams",
1237 : : (1 << OMP_TRAIT_SET_CONSTRUCT),
1238 : : OMP_TRAIT_PROPERTY_NONE, false,
1239 : : NULL
1240 : : },
1241 : : { "parallel",
1242 : : (1 << OMP_TRAIT_SET_CONSTRUCT),
1243 : : OMP_TRAIT_PROPERTY_NONE, false,
1244 : : NULL
1245 : : },
1246 : : { "for",
1247 : : (1 << OMP_TRAIT_SET_CONSTRUCT),
1248 : : OMP_TRAIT_PROPERTY_NONE, false,
1249 : : NULL
1250 : : },
1251 : : { "simd",
1252 : : (1 << OMP_TRAIT_SET_CONSTRUCT),
1253 : : OMP_TRAIT_PROPERTY_CLAUSE_LIST, false,
1254 : : NULL
1255 : : },
1256 : : { NULL, 0, OMP_TRAIT_PROPERTY_NONE, false, NULL } /* OMP_TRAIT_LAST */
1257 : : };
1258 : :
1259 : :
1260 : : /* Return a name from PROP, a property in selectors accepting
1261 : : name lists. */
1262 : :
1263 : : const char *
1264 : 6492 : omp_context_name_list_prop (tree prop)
1265 : : {
1266 : 6492 : gcc_assert (OMP_TP_NAME (prop) == OMP_TP_NAMELIST_NODE);
1267 : 6492 : tree val = OMP_TP_VALUE (prop);
1268 : 6492 : switch (TREE_CODE (val))
1269 : : {
1270 : 5053 : case IDENTIFIER_NODE:
1271 : 5053 : return IDENTIFIER_POINTER (val);
1272 : 1439 : case STRING_CST:
1273 : 1439 : {
1274 : 1439 : const char *ret = TREE_STRING_POINTER (val);
1275 : 2878 : if ((size_t) TREE_STRING_LENGTH (val)
1276 : 2572 : == strlen (ret) + (lang_GNU_Fortran () ? 0 : 1))
1277 : : return ret;
1278 : : return NULL;
1279 : : }
1280 : : default:
1281 : : return NULL;
1282 : : }
1283 : : }
1284 : :
1285 : : /* Diagnose errors in an OpenMP context selector, return CTX if
1286 : : it is correct or error_mark_node otherwise. */
1287 : :
1288 : : tree
1289 : 1522 : omp_check_context_selector (location_t loc, tree ctx)
1290 : : {
1291 : 1522 : bool tss_seen[OMP_TRAIT_SET_LAST], ts_seen[OMP_TRAIT_LAST];
1292 : :
1293 : 1522 : memset (tss_seen, 0, sizeof (tss_seen));
1294 : 3177 : for (tree tss = ctx; tss; tss = TREE_CHAIN (tss))
1295 : : {
1296 : 1755 : enum omp_tss_code tss_code = OMP_TSS_CODE (tss);
1297 : 1755 : bool saw_any_prop = false;
1298 : 1755 : bool saw_other_prop = false;
1299 : :
1300 : : /* We can parse this, but not handle it yet. */
1301 : 1755 : if (tss_code == OMP_TRAIT_SET_TARGET_DEVICE)
1302 : 0 : sorry_at (loc, "%<target_device%> selector set is not supported yet");
1303 : :
1304 : : /* Each trait-set-selector-name can only be specified once. */
1305 : 1755 : if (tss_seen[tss_code])
1306 : : {
1307 : 30 : error_at (loc, "selector set %qs specified more than once",
1308 : 30 : OMP_TSS_NAME (tss));
1309 : 30 : return error_mark_node;
1310 : : }
1311 : : else
1312 : 1725 : tss_seen[tss_code] = true;
1313 : :
1314 : 1725 : memset (ts_seen, 0, sizeof (ts_seen));
1315 : 3916 : for (tree ts = OMP_TSS_TRAIT_SELECTORS (tss); ts; ts = TREE_CHAIN (ts))
1316 : : {
1317 : 2241 : enum omp_ts_code ts_code = OMP_TS_CODE (ts);
1318 : :
1319 : : /* Ignore unknown traits. */
1320 : 2241 : if (ts_code == OMP_TRAIT_INVALID)
1321 : 73 : continue;
1322 : :
1323 : : /* Each trait-selector-name can only be specified once. */
1324 : 2168 : if (ts_seen[ts_code])
1325 : : {
1326 : 15 : error_at (loc,
1327 : : "selector %qs specified more than once in set %qs",
1328 : 15 : OMP_TS_NAME (ts),
1329 : 15 : OMP_TSS_NAME (tss));
1330 : 15 : return error_mark_node;
1331 : : }
1332 : : else
1333 : 2153 : ts_seen[ts_code] = true;
1334 : :
1335 : : /* If trait-property "any" is specified in the "kind"
1336 : : trait-selector of the "device" selector set or the
1337 : : "target_device" selector sets, no other trait-property
1338 : : may be specified in the same selector set. */
1339 : 2153 : if (ts_code == OMP_TRAIT_DEVICE_KIND)
1340 : 676 : for (tree p = OMP_TS_PROPERTIES (ts); p; p = TREE_CHAIN (p))
1341 : : {
1342 : 268 : const char *prop = omp_context_name_list_prop (p);
1343 : 268 : if (!prop)
1344 : 1 : continue;
1345 : 267 : else if (strcmp (prop, "any") == 0)
1346 : : saw_any_prop = true;
1347 : : else
1348 : 205 : saw_other_prop = true;
1349 : : }
1350 : : /* It seems slightly suspicious that the spec's language covers
1351 : : the device_num selector too, but
1352 : : target_device={device_num(whatever),kind(any)}
1353 : : is probably not terribly useful anyway. */
1354 : 1949 : else if (ts_code == OMP_TRAIT_DEVICE_ARCH
1355 : : || ts_code == OMP_TRAIT_DEVICE_ISA
1356 : 1949 : || ts_code == OMP_TRAIT_DEVICE_NUM)
1357 : 338 : saw_other_prop = true;
1358 : :
1359 : : /* Each trait-property can only be specified once in a trait-selector
1360 : : other than the construct selector set. FIXME: only handles
1361 : : name-list properties, not clause-list properties, since the
1362 : : "requires" selector is not implemented yet (PR 113067). */
1363 : 2153 : if (tss_code != OMP_TRAIT_SET_CONSTRUCT)
1364 : 3821 : for (tree p1 = OMP_TS_PROPERTIES (ts); p1; p1 = TREE_CHAIN (p1))
1365 : : {
1366 : 1559 : if (OMP_TP_NAME (p1) != OMP_TP_NAMELIST_NODE)
1367 : : break;
1368 : 1071 : const char *n1 = omp_context_name_list_prop (p1);
1369 : 1071 : if (!n1)
1370 : 2 : continue;
1371 : 1427 : for (tree p2 = TREE_CHAIN (p1); p2; p2 = TREE_CHAIN (p2))
1372 : : {
1373 : 388 : const char *n2 = omp_context_name_list_prop (p2);
1374 : 388 : if (!n2)
1375 : 0 : continue;
1376 : 388 : if (!strcmp (n1, n2))
1377 : : {
1378 : 30 : error_at (loc,
1379 : : "trait-property %qs specified more "
1380 : : "than once in %qs selector",
1381 : 30 : n1, OMP_TS_NAME (ts));
1382 : 30 : return error_mark_node;
1383 : : }
1384 : : }
1385 : : }
1386 : :
1387 : : /* Check for unknown properties. */
1388 : 2123 : if (omp_ts_map[ts_code].valid_properties == NULL)
1389 : 1535 : continue;
1390 : 1848 : for (tree p = OMP_TS_PROPERTIES (ts); p; p = TREE_CHAIN (p))
1391 : 2682 : for (unsigned j = 0; ; j++)
1392 : : {
1393 : 3359 : const char *candidate
1394 : 3359 : = omp_ts_map[ts_code].valid_properties[j];
1395 : 3359 : if (candidate == NULL)
1396 : : {
1397 : : /* We've reached the end of the candidate array. */
1398 : 69 : if (ts_code == OMP_TRAIT_IMPLEMENTATION_ADMO)
1399 : : /* FIXME: not sure why this is an error vs warnings
1400 : : for the others, + incorrect/unknown wording? */
1401 : : {
1402 : 5 : error_at (loc,
1403 : : "incorrect property %qs of %qs selector",
1404 : 5 : IDENTIFIER_POINTER (OMP_TP_NAME (p)),
1405 : : "atomic_default_mem_order");
1406 : 5 : return error_mark_node;
1407 : : }
1408 : 64 : if (OMP_TP_NAME (p) == OMP_TP_NAMELIST_NODE
1409 : 64 : && (TREE_CODE (OMP_TP_VALUE (p)) == STRING_CST))
1410 : 18 : warning_at (loc, OPT_Wopenmp,
1411 : : "unknown property %qE of %qs selector",
1412 : 9 : OMP_TP_VALUE (p),
1413 : 9 : OMP_TS_NAME (ts));
1414 : 55 : else if (OMP_TP_NAME (p) == OMP_TP_NAMELIST_NODE)
1415 : 110 : warning_at (loc, OPT_Wopenmp,
1416 : : "unknown property %qs of %qs selector",
1417 : : omp_context_name_list_prop (p),
1418 : 55 : OMP_TS_NAME (ts));
1419 : 0 : else if (OMP_TP_NAME (p))
1420 : 0 : warning_at (loc, OPT_Wopenmp,
1421 : : "unknown property %qs of %qs selector",
1422 : 0 : IDENTIFIER_POINTER (OMP_TP_NAME (p)),
1423 : 0 : OMP_TS_NAME (ts));
1424 : : break;
1425 : : }
1426 : 3290 : else if (OMP_TP_NAME (p) == OMP_TP_NAMELIST_NODE)
1427 : : /* Property-list traits. */
1428 : : {
1429 : 3054 : const char *str = omp_context_name_list_prop (p);
1430 : 3054 : if (str && !strcmp (str, candidate))
1431 : : break;
1432 : : }
1433 : 236 : else if (!strcmp (IDENTIFIER_POINTER (OMP_TP_NAME (p)),
1434 : : candidate))
1435 : : /* Identifier traits. */
1436 : : break;
1437 : 2682 : }
1438 : : }
1439 : :
1440 : 1675 : if (saw_any_prop && saw_other_prop)
1441 : : {
1442 : 20 : error_at (loc,
1443 : : "no other trait-property may be specified "
1444 : : "in the same selector set with %<kind(\"any\")%>");
1445 : 20 : return error_mark_node;
1446 : : }
1447 : : }
1448 : : return ctx;
1449 : : }
1450 : :
1451 : :
1452 : : /* Register VARIANT as variant of some base function marked with
1453 : : #pragma omp declare variant. CONSTRUCT is corresponding list of
1454 : : trait-selectors for the construct selector set. This is stashed as the
1455 : : value of the "omp declare variant variant" attribute on VARIANT. */
1456 : : void
1457 : 1285 : omp_mark_declare_variant (location_t loc, tree variant, tree construct)
1458 : : {
1459 : : /* Ignore this variant if it contains unknown construct selectors.
1460 : : It will never match, and the front ends have already issued a warning
1461 : : about it. */
1462 : 1893 : for (tree c = construct; c; c = TREE_CHAIN (c))
1463 : 664 : if (OMP_TS_CODE (c) == OMP_TRAIT_INVALID)
1464 : : return;
1465 : :
1466 : 1229 : tree attr = lookup_attribute ("omp declare variant variant",
1467 : 1229 : DECL_ATTRIBUTES (variant));
1468 : 1229 : if (attr == NULL_TREE)
1469 : : {
1470 : 761 : attr = tree_cons (get_identifier ("omp declare variant variant"),
1471 : : unshare_expr (construct),
1472 : 761 : DECL_ATTRIBUTES (variant));
1473 : 761 : DECL_ATTRIBUTES (variant) = attr;
1474 : 761 : return;
1475 : : }
1476 : 468 : if ((TREE_VALUE (attr) != NULL_TREE) != (construct != NULL_TREE)
1477 : 468 : || (construct != NULL_TREE
1478 : 54 : && omp_context_selector_set_compare (OMP_TRAIT_SET_CONSTRUCT,
1479 : 54 : TREE_VALUE (attr),
1480 : : construct)))
1481 : 44 : error_at (loc, "%qD used as a variant with incompatible %<construct%> "
1482 : : "selector sets", variant);
1483 : : }
1484 : :
1485 : :
1486 : : /* Constructors for context selectors. */
1487 : :
1488 : : tree
1489 : 1759 : make_trait_set_selector (enum omp_tss_code code, tree selectors, tree chain)
1490 : : {
1491 : 1759 : return tree_cons (build_int_cst (integer_type_node, code),
1492 : 1759 : selectors, chain);
1493 : : }
1494 : :
1495 : : tree
1496 : 2326 : make_trait_selector (enum omp_ts_code code, tree score, tree properties,
1497 : : tree chain)
1498 : : {
1499 : 2326 : if (score == NULL_TREE)
1500 : 1998 : return tree_cons (build_int_cst (integer_type_node, code),
1501 : : properties, chain);
1502 : : else
1503 : 328 : return tree_cons (build_int_cst (integer_type_node, code),
1504 : : tree_cons (OMP_TS_SCORE_NODE, score, properties),
1505 : : chain);
1506 : : }
1507 : :
1508 : : tree
1509 : 1628 : make_trait_property (tree name, tree value, tree chain)
1510 : : {
1511 : 1628 : return tree_cons (name, value, chain);
1512 : : }
1513 : :
1514 : : /* Return 1 if context selector matches the current OpenMP context, 0
1515 : : if it does not and -1 if it is unknown and need to be determined later.
1516 : : Some properties can be checked right away during parsing (this routine),
1517 : : others need to wait until the whole TU is parsed, others need to wait until
1518 : : IPA, others until vectorization. */
1519 : :
1520 : : int
1521 : 1951 : omp_context_selector_matches (tree ctx)
1522 : : {
1523 : 1951 : int ret = 1;
1524 : 3406 : for (tree tss = ctx; tss; tss = TREE_CHAIN (tss))
1525 : : {
1526 : 2212 : enum omp_tss_code set = OMP_TSS_CODE (tss);
1527 : 2212 : tree selectors = OMP_TSS_TRAIT_SELECTORS (tss);
1528 : :
1529 : : /* Immediately reject the match if there are any ignored
1530 : : selectors present. */
1531 : 5043 : for (tree ts = selectors; ts; ts = TREE_CHAIN (ts))
1532 : 2899 : if (OMP_TS_CODE (ts) == OMP_TRAIT_INVALID)
1533 : : return 0;
1534 : :
1535 : 2144 : if (set == OMP_TRAIT_SET_CONSTRUCT)
1536 : : {
1537 : : /* For now, ignore the construct set. While something can be
1538 : : determined already during parsing, we don't know until end of TU
1539 : : whether additional constructs aren't added through declare variant
1540 : : unless "omp declare variant variant" attribute exists already
1541 : : (so in most of the cases), and we'd need to maintain set of
1542 : : surrounding OpenMP constructs, which is better handled during
1543 : : gimplification. */
1544 : 607 : if (symtab->state == PARSING)
1545 : : {
1546 : 326 : ret = -1;
1547 : 326 : continue;
1548 : : }
1549 : :
1550 : 281 : int nconstructs = list_length (selectors);
1551 : 281 : enum tree_code *constructs = NULL;
1552 : 281 : if (nconstructs)
1553 : : {
1554 : : /* Even though this alloca appears in a loop over selector
1555 : : sets, it does not repeatedly grow the stack, because
1556 : : there can be only one construct selector set specified.
1557 : : This is enforced by omp_check_context_selector. */
1558 : 281 : constructs
1559 : 281 : = (enum tree_code *) alloca (nconstructs
1560 : : * sizeof (enum tree_code));
1561 : 281 : omp_construct_traits_to_codes (selectors, nconstructs,
1562 : : constructs);
1563 : : }
1564 : :
1565 : 281 : if (cfun && (cfun->curr_properties & PROP_gimple_any) != 0)
1566 : : {
1567 : 9 : if (!cfun->after_inlining)
1568 : : {
1569 : 0 : ret = -1;
1570 : 0 : continue;
1571 : : }
1572 : : int i;
1573 : 9 : for (i = 0; i < nconstructs; ++i)
1574 : 9 : if (constructs[i] == OMP_SIMD)
1575 : : break;
1576 : 9 : if (i < nconstructs)
1577 : : {
1578 : 9 : ret = -1;
1579 : 9 : continue;
1580 : : }
1581 : : /* If there is no simd, assume it is ok after IPA,
1582 : : constructs should have been checked before. */
1583 : 0 : continue;
1584 : 0 : }
1585 : :
1586 : 272 : int r = omp_construct_selector_matches (constructs, nconstructs,
1587 : : NULL);
1588 : 272 : if (r == 0)
1589 : : return 0;
1590 : 154 : if (r == -1)
1591 : 20 : ret = -1;
1592 : 154 : continue;
1593 : 154 : }
1594 : 2654 : for (tree ts = selectors; ts; ts = TREE_CHAIN (ts))
1595 : : {
1596 : 1688 : enum omp_ts_code sel = OMP_TS_CODE (ts);
1597 : 1688 : switch (sel)
1598 : : {
1599 : 303 : case OMP_TRAIT_IMPLEMENTATION_VENDOR:
1600 : 303 : if (set == OMP_TRAIT_SET_IMPLEMENTATION)
1601 : 785 : for (tree p = OMP_TS_PROPERTIES (ts); p; p = TREE_CHAIN (p))
1602 : : {
1603 : 318 : const char *prop = omp_context_name_list_prop (p);
1604 : 318 : if (prop == NULL)
1605 : : return 0;
1606 : 317 : if (!strcmp (prop, "gnu"))
1607 : 179 : continue;
1608 : : return 0;
1609 : : }
1610 : : break;
1611 : 30 : case OMP_TRAIT_IMPLEMENTATION_EXTENSION:
1612 : 30 : if (set == OMP_TRAIT_SET_IMPLEMENTATION)
1613 : : /* We don't support any extensions right now. */
1614 : : return 0;
1615 : : break;
1616 : 120 : case OMP_TRAIT_IMPLEMENTATION_ADMO:
1617 : 120 : if (set == OMP_TRAIT_SET_IMPLEMENTATION)
1618 : : {
1619 : 120 : if (cfun && (cfun->curr_properties & PROP_gimple_any) != 0)
1620 : : break;
1621 : :
1622 : 120 : enum omp_memory_order omo
1623 : : = ((enum omp_memory_order)
1624 : 120 : (omp_requires_mask
1625 : : & OMP_REQUIRES_ATOMIC_DEFAULT_MEM_ORDER));
1626 : 120 : if (omo == OMP_MEMORY_ORDER_UNSPECIFIED)
1627 : : {
1628 : : /* We don't know yet, until end of TU. */
1629 : 65 : if (symtab->state == PARSING)
1630 : : {
1631 : : ret = -1;
1632 : : break;
1633 : : }
1634 : : else
1635 : : omo = OMP_MEMORY_ORDER_RELAXED;
1636 : : }
1637 : 55 : tree p = OMP_TS_PROPERTIES (ts);
1638 : 55 : const char *prop = IDENTIFIER_POINTER (OMP_TP_NAME (p));
1639 : 55 : if (!strcmp (prop, "relaxed")
1640 : 2 : && omo != OMP_MEMORY_ORDER_RELAXED)
1641 : : return 0;
1642 : 53 : else if (!strcmp (prop, "seq_cst")
1643 : 53 : && omo != OMP_MEMORY_ORDER_SEQ_CST)
1644 : : return 0;
1645 : 53 : else if (!strcmp (prop, "acq_rel")
1646 : 0 : && omo != OMP_MEMORY_ORDER_ACQ_REL)
1647 : : return 0;
1648 : 53 : else if (!strcmp (prop, "acquire")
1649 : 0 : && omo != OMP_MEMORY_ORDER_ACQUIRE)
1650 : : return 0;
1651 : 53 : else if (!strcmp (prop, "release")
1652 : 0 : && omo != OMP_MEMORY_ORDER_RELEASE)
1653 : : return 0;
1654 : : }
1655 : : break;
1656 : 167 : case OMP_TRAIT_DEVICE_ARCH:
1657 : 167 : if (set == OMP_TRAIT_SET_DEVICE)
1658 : 414 : for (tree p = OMP_TS_PROPERTIES (ts); p; p = TREE_CHAIN (p))
1659 : : {
1660 : 172 : const char *arch = omp_context_name_list_prop (p);
1661 : 172 : if (arch == NULL)
1662 : : return 0;
1663 : 172 : int r = 0;
1664 : 172 : if (targetm.omp.device_kind_arch_isa != NULL)
1665 : 172 : r = targetm.omp.device_kind_arch_isa (omp_device_arch,
1666 : : arch);
1667 : 172 : if (r == 0 || (r == -1 && symtab->state != PARSING))
1668 : : {
1669 : : /* If we are or might be in a target region or
1670 : : declare target function, need to take into account
1671 : : also offloading values. */
1672 : 92 : if (!omp_maybe_offloaded ())
1673 : 92 : return 0;
1674 : : if (ENABLE_OFFLOADING)
1675 : : {
1676 : : const char *arches = omp_offload_device_arch;
1677 : : if (omp_offload_device_kind_arch_isa (arches,
1678 : : arch))
1679 : : {
1680 : : ret = -1;
1681 : : continue;
1682 : : }
1683 : : }
1684 : : return 0;
1685 : : }
1686 : : else if (r == -1)
1687 : : ret = -1;
1688 : : /* If arch matches on the host, it still might not match
1689 : : in the offloading region. */
1690 : : else if (omp_maybe_offloaded ())
1691 : : ret = -1;
1692 : : }
1693 : : break;
1694 : 20 : case OMP_TRAIT_IMPLEMENTATION_UNIFIED_ADDRESS:
1695 : 20 : if (set == OMP_TRAIT_SET_IMPLEMENTATION)
1696 : : {
1697 : 20 : if (cfun && (cfun->curr_properties & PROP_gimple_any) != 0)
1698 : : break;
1699 : :
1700 : 20 : if ((omp_requires_mask & OMP_REQUIRES_UNIFIED_ADDRESS) == 0)
1701 : : {
1702 : 20 : if (symtab->state == PARSING)
1703 : : ret = -1;
1704 : : else
1705 : : return 0;
1706 : : }
1707 : : }
1708 : : break;
1709 : 15 : case OMP_TRAIT_IMPLEMENTATION_UNIFIED_SHARED_MEMORY:
1710 : 15 : if (set == OMP_TRAIT_SET_IMPLEMENTATION)
1711 : : {
1712 : 15 : if (cfun && (cfun->curr_properties & PROP_gimple_any) != 0)
1713 : : break;
1714 : :
1715 : 15 : if ((omp_requires_mask
1716 : : & OMP_REQUIRES_UNIFIED_SHARED_MEMORY) == 0)
1717 : : {
1718 : 15 : if (symtab->state == PARSING)
1719 : : ret = -1;
1720 : : else
1721 : : return 0;
1722 : : }
1723 : : }
1724 : : break;
1725 : 5 : case OMP_TRAIT_IMPLEMENTATION_SELF_MAPS:
1726 : 5 : if (set == OMP_TRAIT_SET_IMPLEMENTATION)
1727 : : {
1728 : 5 : if (cfun && (cfun->curr_properties & PROP_gimple_any) != 0)
1729 : : break;
1730 : :
1731 : 5 : if ((omp_requires_mask
1732 : : & OMP_REQUIRES_SELF_MAPS) == 0)
1733 : : {
1734 : 5 : if (symtab->state == PARSING)
1735 : : ret = -1;
1736 : : else
1737 : : return 0;
1738 : : }
1739 : : }
1740 : : break;
1741 : 10 : case OMP_TRAIT_IMPLEMENTATION_DYNAMIC_ALLOCATORS:
1742 : 10 : if (set == OMP_TRAIT_SET_IMPLEMENTATION)
1743 : : {
1744 : 10 : if (cfun && (cfun->curr_properties & PROP_gimple_any) != 0)
1745 : : break;
1746 : :
1747 : 10 : if ((omp_requires_mask
1748 : : & OMP_REQUIRES_DYNAMIC_ALLOCATORS) == 0)
1749 : : {
1750 : 10 : if (symtab->state == PARSING)
1751 : : ret = -1;
1752 : : else
1753 : : return 0;
1754 : : }
1755 : : }
1756 : : break;
1757 : 10 : case OMP_TRAIT_IMPLEMENTATION_REVERSE_OFFLOAD:
1758 : 10 : if (set == OMP_TRAIT_SET_IMPLEMENTATION)
1759 : : {
1760 : 10 : if (cfun && (cfun->curr_properties & PROP_gimple_any) != 0)
1761 : : break;
1762 : :
1763 : 10 : if ((omp_requires_mask & OMP_REQUIRES_REVERSE_OFFLOAD) == 0)
1764 : : {
1765 : 10 : if (symtab->state == PARSING)
1766 : : ret = -1;
1767 : : else
1768 : : return 0;
1769 : : }
1770 : : }
1771 : : break;
1772 : 231 : case OMP_TRAIT_DEVICE_KIND:
1773 : 231 : if (set == OMP_TRAIT_SET_DEVICE)
1774 : 654 : for (tree p = OMP_TS_PROPERTIES (ts); p; p = TREE_CHAIN (p))
1775 : : {
1776 : 255 : const char *prop = omp_context_name_list_prop (p);
1777 : 255 : if (prop == NULL)
1778 : : return 0;
1779 : 254 : if (!strcmp (prop, "any"))
1780 : 24 : continue;
1781 : 230 : if (!strcmp (prop, "host"))
1782 : : {
1783 : : #ifdef ACCEL_COMPILER
1784 : : return 0;
1785 : : #else
1786 : 61 : if (omp_maybe_offloaded ())
1787 : : ret = -1;
1788 : 61 : continue;
1789 : : #endif
1790 : : }
1791 : 169 : if (!strcmp (prop, "nohost"))
1792 : : {
1793 : : #ifndef ACCEL_COMPILER
1794 : : if (omp_maybe_offloaded ())
1795 : : ret = -1;
1796 : : else
1797 : : return 0;
1798 : : #endif
1799 : : continue;
1800 : : }
1801 : 153 : int r = 0;
1802 : 153 : if (targetm.omp.device_kind_arch_isa != NULL)
1803 : 153 : r = targetm.omp.device_kind_arch_isa (omp_device_kind,
1804 : : prop);
1805 : : else
1806 : 0 : r = strcmp (prop, "cpu") == 0;
1807 : 153 : if (r == 0 || (r == -1 && symtab->state != PARSING))
1808 : : {
1809 : : /* If we are or might be in a target region or
1810 : : declare target function, need to take into account
1811 : : also offloading values. */
1812 : : if (!omp_maybe_offloaded ())
1813 : : return 0;
1814 : : if (ENABLE_OFFLOADING)
1815 : : {
1816 : : const char *kinds = omp_offload_device_kind;
1817 : : if (omp_offload_device_kind_arch_isa (kinds, prop))
1818 : : {
1819 : : ret = -1;
1820 : : continue;
1821 : : }
1822 : : }
1823 : : return 0;
1824 : : }
1825 : : else if (r == -1)
1826 : : ret = -1;
1827 : : /* If kind matches on the host, it still might not match
1828 : : in the offloading region. */
1829 : : else if (omp_maybe_offloaded ())
1830 : : ret = -1;
1831 : : }
1832 : : break;
1833 : 368 : case OMP_TRAIT_DEVICE_ISA:
1834 : 368 : if (set == OMP_TRAIT_SET_DEVICE)
1835 : 1176 : for (tree p = OMP_TS_PROPERTIES (ts); p; p = TREE_CHAIN (p))
1836 : : {
1837 : 558 : const char *isa = omp_context_name_list_prop (p);
1838 : 558 : if (isa == NULL)
1839 : : return 0;
1840 : 558 : int r = 0;
1841 : 558 : if (targetm.omp.device_kind_arch_isa != NULL)
1842 : 558 : r = targetm.omp.device_kind_arch_isa (omp_device_isa,
1843 : : isa);
1844 : 558 : if (r == 0 || (r == -1 && symtab->state != PARSING))
1845 : : {
1846 : : /* If isa is valid on the target, but not in the
1847 : : current function and current function has
1848 : : #pragma omp declare simd on it, some simd clones
1849 : : might have the isa added later on. */
1850 : 110 : if (r == -1
1851 : 110 : && targetm.simd_clone.compute_vecsize_and_simdlen
1852 : 110 : && (cfun == NULL || !cfun->after_inlining))
1853 : : {
1854 : 26 : tree attrs
1855 : 26 : = DECL_ATTRIBUTES (current_function_decl);
1856 : 26 : if (lookup_attribute ("omp declare simd", attrs))
1857 : : {
1858 : 17 : ret = -1;
1859 : 17 : continue;
1860 : : }
1861 : : }
1862 : : /* If we are or might be in a target region or
1863 : : declare target function, need to take into account
1864 : : also offloading values. */
1865 : 118 : if (!omp_maybe_offloaded ())
1866 : 118 : return 0;
1867 : : if (ENABLE_OFFLOADING)
1868 : : {
1869 : : const char *isas = omp_offload_device_isa;
1870 : : if (omp_offload_device_kind_arch_isa (isas, isa))
1871 : : {
1872 : : ret = -1;
1873 : : continue;
1874 : : }
1875 : : }
1876 : : return 0;
1877 : : }
1878 : : else if (r == -1)
1879 : : ret = -1;
1880 : : /* If isa matches on the host, it still might not match
1881 : : in the offloading region. */
1882 : : else if (omp_maybe_offloaded ())
1883 : : ret = -1;
1884 : : }
1885 : : break;
1886 : 409 : case OMP_TRAIT_USER_CONDITION:
1887 : 409 : if (set == OMP_TRAIT_SET_USER)
1888 : 827 : for (tree p = OMP_TS_PROPERTIES (ts); p; p = TREE_CHAIN (p))
1889 : 406 : if (OMP_TP_NAME (p) == NULL_TREE)
1890 : : {
1891 : 406 : if (integer_zerop (OMP_TP_VALUE (p)))
1892 : : return 0;
1893 : 279 : if (integer_nonzerop (OMP_TP_VALUE (p)))
1894 : : break;
1895 : : ret = -1;
1896 : : }
1897 : : break;
1898 : : default:
1899 : : break;
1900 : : }
1901 : : }
1902 : : }
1903 : : return ret;
1904 : : }
1905 : :
1906 : : /* Compare construct={simd} CLAUSES1 with CLAUSES2, return 0/-1/1/2 as
1907 : : in omp_context_selector_set_compare. */
1908 : :
1909 : : static int
1910 : 18 : omp_construct_simd_compare (tree clauses1, tree clauses2)
1911 : : {
1912 : 18 : if (clauses1 == NULL_TREE)
1913 : 0 : return clauses2 == NULL_TREE ? 0 : -1;
1914 : 18 : if (clauses2 == NULL_TREE)
1915 : : return 1;
1916 : :
1917 : 54 : int r = 0;
1918 : 36 : struct declare_variant_simd_data {
1919 : : bool inbranch, notinbranch;
1920 : : tree simdlen;
1921 : : auto_vec<tree,16> data_sharing;
1922 : : auto_vec<tree,16> aligned;
1923 : 36 : declare_variant_simd_data ()
1924 : 36 : : inbranch(false), notinbranch(false), simdlen(NULL_TREE) {}
1925 : 126 : } data[2];
1926 : : unsigned int i;
1927 : 54 : for (i = 0; i < 2; i++)
1928 : 196 : for (tree c = i ? clauses2 : clauses1; c; c = OMP_CLAUSE_CHAIN (c))
1929 : : {
1930 : 124 : vec<tree> *v;
1931 : 124 : switch (OMP_CLAUSE_CODE (c))
1932 : : {
1933 : 12 : case OMP_CLAUSE_INBRANCH:
1934 : 12 : data[i].inbranch = true;
1935 : 12 : continue;
1936 : 24 : case OMP_CLAUSE_NOTINBRANCH:
1937 : 24 : data[i].notinbranch = true;
1938 : 24 : continue;
1939 : 36 : case OMP_CLAUSE_SIMDLEN:
1940 : 36 : data[i].simdlen = OMP_CLAUSE_SIMDLEN_EXPR (c);
1941 : 36 : continue;
1942 : 36 : case OMP_CLAUSE_UNIFORM:
1943 : 36 : case OMP_CLAUSE_LINEAR:
1944 : 36 : v = &data[i].data_sharing;
1945 : 36 : break;
1946 : 16 : case OMP_CLAUSE_ALIGNED:
1947 : 16 : v = &data[i].aligned;
1948 : 16 : break;
1949 : 0 : default:
1950 : 0 : gcc_unreachable ();
1951 : : }
1952 : 52 : unsigned HOST_WIDE_INT argno = tree_to_uhwi (OMP_CLAUSE_DECL (c));
1953 : 104 : if (argno >= v->length ())
1954 : 52 : v->safe_grow_cleared (argno + 1, true);
1955 : 52 : (*v)[argno] = c;
1956 : : }
1957 : : /* Here, r is used as a bitmask, 2 is set if CLAUSES1 has something
1958 : : CLAUSES2 doesn't, 1 is set if CLAUSES2 has something CLAUSES1
1959 : : doesn't. Thus, r == 3 implies return value 2, r == 1 implies
1960 : : -1, r == 2 implies 1 and r == 0 implies 0. */
1961 : 18 : if (data[0].inbranch != data[1].inbranch)
1962 : 0 : r |= data[0].inbranch ? 2 : 1;
1963 : 18 : if (data[0].notinbranch != data[1].notinbranch)
1964 : 0 : r |= data[0].notinbranch ? 2 : 1;
1965 : 18 : if (!simple_cst_equal (data[0].simdlen, data[1].simdlen))
1966 : : {
1967 : 0 : if (data[0].simdlen && data[1].simdlen)
1968 : : return 2;
1969 : 0 : r |= data[0].simdlen ? 2 : 1;
1970 : : }
1971 : 54 : if (data[0].data_sharing.length () < data[1].data_sharing.length ()
1972 : 36 : || data[0].aligned.length () < data[1].aligned.length ())
1973 : 0 : r |= 1;
1974 : : tree c1, c2;
1975 : 58 : FOR_EACH_VEC_ELT (data[0].data_sharing, i, c1)
1976 : : {
1977 : 48 : c2 = (i < data[1].data_sharing.length ()
1978 : 96 : ? data[1].data_sharing[i] : NULL_TREE);
1979 : 48 : if ((c1 == NULL_TREE) != (c2 == NULL_TREE))
1980 : : {
1981 : 0 : r |= c1 != NULL_TREE ? 2 : 1;
1982 : 0 : continue;
1983 : : }
1984 : 48 : if (c1 == NULL_TREE)
1985 : 30 : continue;
1986 : 18 : if (OMP_CLAUSE_CODE (c1) != OMP_CLAUSE_CODE (c2))
1987 : : return 2;
1988 : 13 : if (OMP_CLAUSE_CODE (c1) != OMP_CLAUSE_LINEAR)
1989 : 7 : continue;
1990 : 6 : if (OMP_CLAUSE_LINEAR_VARIABLE_STRIDE (c1)
1991 : 6 : != OMP_CLAUSE_LINEAR_VARIABLE_STRIDE (c2))
1992 : : return 2;
1993 : 6 : if (OMP_CLAUSE_LINEAR_KIND (c1) != OMP_CLAUSE_LINEAR_KIND (c2))
1994 : : return 2;
1995 : 6 : if (!simple_cst_equal (OMP_CLAUSE_LINEAR_STEP (c1),
1996 : 6 : OMP_CLAUSE_LINEAR_STEP (c2)))
1997 : : return 2;
1998 : : }
1999 : 23 : FOR_EACH_VEC_ELT (data[0].aligned, i, c1)
2000 : : {
2001 : 36 : c2 = i < data[1].aligned.length () ? data[1].aligned[i] : NULL_TREE;
2002 : 18 : if ((c1 == NULL_TREE) != (c2 == NULL_TREE))
2003 : : {
2004 : 0 : r |= c1 != NULL_TREE ? 2 : 1;
2005 : 0 : continue;
2006 : : }
2007 : 18 : if (c1 == NULL_TREE)
2008 : 12 : continue;
2009 : 6 : if (!simple_cst_equal (OMP_CLAUSE_ALIGNED_ALIGNMENT (c1),
2010 : 6 : OMP_CLAUSE_ALIGNED_ALIGNMENT (c2)))
2011 : : return 2;
2012 : : }
2013 : 5 : switch (r)
2014 : : {
2015 : : case 0: return 0;
2016 : 0 : case 1: return -1;
2017 : 0 : case 2: return 1;
2018 : : case 3: return 2;
2019 : 0 : default: gcc_unreachable ();
2020 : : }
2021 : 54 : }
2022 : :
2023 : : /* Compare properties of selectors SEL from SET other than construct.
2024 : : CTX1 and CTX2 are the lists of properties to compare.
2025 : : Return 0/-1/1/2 as in omp_context_selector_set_compare.
2026 : : Unlike set names or selector names, properties can have duplicates. */
2027 : :
2028 : : static int
2029 : 55 : omp_context_selector_props_compare (enum omp_tss_code set,
2030 : : enum omp_ts_code sel,
2031 : : tree ctx1, tree ctx2)
2032 : : {
2033 : 55 : int ret = 0;
2034 : 160 : for (int pass = 0; pass < 2; pass++)
2035 : 330 : for (tree p1 = pass ? ctx2 : ctx1; p1; p1 = TREE_CHAIN (p1))
2036 : : {
2037 : 120 : tree p2;
2038 : 310 : for (p2 = pass ? ctx1 : ctx2; p2; p2 = TREE_CHAIN (p2))
2039 : 180 : if (OMP_TP_NAME (p1) == OMP_TP_NAME (p2))
2040 : : {
2041 : 180 : if (OMP_TP_NAME (p1) == NULL_TREE)
2042 : : {
2043 : 40 : if (set == OMP_TRAIT_SET_USER
2044 : 40 : && sel == OMP_TRAIT_USER_CONDITION)
2045 : : {
2046 : 80 : if (integer_zerop (OMP_TP_VALUE (p1))
2047 : 40 : != integer_zerop (OMP_TP_VALUE (p2)))
2048 : : return 2;
2049 : : break;
2050 : : }
2051 : 0 : if (simple_cst_equal (OMP_TP_VALUE (p1), OMP_TP_VALUE (p2)))
2052 : : break;
2053 : : }
2054 : 140 : else if (OMP_TP_NAME (p1) == OMP_TP_NAMELIST_NODE)
2055 : : {
2056 : : /* Handle string constant vs identifier comparison for
2057 : : name-list properties. */
2058 : 140 : const char *n1 = omp_context_name_list_prop (p1);
2059 : 140 : const char *n2 = omp_context_name_list_prop (p2);
2060 : 140 : if (n1 && n2 && !strcmp (n1, n2))
2061 : : break;
2062 : : }
2063 : : else
2064 : : break;
2065 : : }
2066 : 10 : if (p2 == NULL_TREE)
2067 : : {
2068 : 10 : int r = pass ? -1 : 1;
2069 : 10 : if (ret && ret != r)
2070 : : return 2;
2071 : 10 : else if (pass)
2072 : 5 : return r;
2073 : : else
2074 : : {
2075 : : ret = r;
2076 : : break;
2077 : : }
2078 : : }
2079 : : }
2080 : : return ret;
2081 : : }
2082 : :
2083 : : /* Compare single context selector sets CTX1 and CTX2 with SET name.
2084 : : CTX1 and CTX2 are lists of trait-selectors.
2085 : : Return 0 if CTX1 is equal to CTX2,
2086 : : -1 if CTX1 is a strict subset of CTX2,
2087 : : 1 if CTX2 is a strict subset of CTX1, or
2088 : : 2 if neither context is a subset of another one. */
2089 : :
2090 : : int
2091 : 333 : omp_context_selector_set_compare (enum omp_tss_code set, tree ctx1, tree ctx2)
2092 : : {
2093 : :
2094 : : /* If either list includes an ignored selector trait, neither can
2095 : : be a subset of the other. */
2096 : 777 : for (tree ts = ctx1; ts; ts = TREE_CHAIN (ts))
2097 : 444 : if (OMP_TS_CODE (ts) == OMP_TRAIT_INVALID)
2098 : : return 2;
2099 : 795 : for (tree ts = ctx2; ts; ts = TREE_CHAIN (ts))
2100 : 462 : if (OMP_TS_CODE (ts) == OMP_TRAIT_INVALID)
2101 : : return 2;
2102 : :
2103 : 333 : bool swapped = false;
2104 : 333 : int ret = 0;
2105 : 333 : int len1 = list_length (ctx1);
2106 : 333 : int len2 = list_length (ctx2);
2107 : 333 : int cnt = 0;
2108 : 333 : if (len1 < len2)
2109 : : {
2110 : 43 : swapped = true;
2111 : 43 : std::swap (ctx1, ctx2);
2112 : 43 : std::swap (len1, len2);
2113 : : }
2114 : :
2115 : 333 : if (set == OMP_TRAIT_SET_CONSTRUCT)
2116 : : {
2117 : : tree ts1;
2118 : : tree ts2 = ctx2;
2119 : : /* Handle construct set specially. In this case the order
2120 : : of the selector matters too. */
2121 : 228 : for (ts1 = ctx1; ts1; ts1 = TREE_CHAIN (ts1))
2122 : 223 : if (OMP_TS_CODE (ts1) == OMP_TS_CODE (ts2))
2123 : : {
2124 : 163 : int r = 0;
2125 : 163 : if (OMP_TS_CODE (ts1) == OMP_TRAIT_CONSTRUCT_SIMD)
2126 : 18 : r = omp_construct_simd_compare (OMP_TS_PROPERTIES (ts1),
2127 : 18 : OMP_TS_PROPERTIES (ts2));
2128 : 163 : if (r == 2 || (ret && r && (ret < 0) != (r < 0)))
2129 : 13 : return 2;
2130 : 150 : if (ret == 0)
2131 : 91 : ret = r;
2132 : 150 : ts2 = TREE_CHAIN (ts2);
2133 : 150 : if (ts2 == NULL_TREE)
2134 : : {
2135 : 84 : ts1 = TREE_CHAIN (ts1);
2136 : 84 : break;
2137 : : }
2138 : : }
2139 : 60 : else if (ret < 0)
2140 : : return 2;
2141 : : else
2142 : : ret = 1;
2143 : 89 : if (ts2 != NULL_TREE)
2144 : : return 2;
2145 : 84 : if (ts1 != NULL_TREE)
2146 : : {
2147 : 28 : if (ret < 0)
2148 : : return 2;
2149 : : ret = 1;
2150 : : }
2151 : 56 : if (ret == 0)
2152 : : return 0;
2153 : 64 : return swapped ? -ret : ret;
2154 : : }
2155 : 359 : for (tree ts1 = ctx1; ts1; ts1 = TREE_CHAIN (ts1))
2156 : : {
2157 : 251 : enum omp_ts_code sel = OMP_TS_CODE (ts1);
2158 : 251 : tree ts2;
2159 : 334 : for (ts2 = ctx2; ts2; ts2 = TREE_CHAIN (ts2))
2160 : 261 : if (sel == OMP_TS_CODE (ts2))
2161 : : {
2162 : 178 : tree score1 = OMP_TS_SCORE (ts1);
2163 : 178 : tree score2 = OMP_TS_SCORE (ts2);
2164 : 178 : if (score1 && score2 && !simple_cst_equal (score1, score2))
2165 : : return 2;
2166 : :
2167 : 119 : int r = omp_context_selector_props_compare (set, OMP_TS_CODE (ts1),
2168 : 55 : OMP_TS_PROPERTIES (ts1),
2169 : 55 : OMP_TS_PROPERTIES (ts2));
2170 : 55 : if (r == 2 || (ret && r && (ret < 0) != (r < 0)))
2171 : : return 2;
2172 : 55 : if (ret == 0)
2173 : 50 : ret = r;
2174 : 55 : cnt++;
2175 : 55 : break;
2176 : : }
2177 : 128 : if (ts2 == NULL_TREE)
2178 : : {
2179 : 73 : if (ret == -1)
2180 : : return 2;
2181 : : ret = 1;
2182 : : }
2183 : : }
2184 : 108 : if (cnt < len2)
2185 : : return 2;
2186 : 50 : if (ret == 0)
2187 : : return 0;
2188 : 20 : return swapped ? -ret : ret;
2189 : : }
2190 : :
2191 : : /* Compare whole context selector specification CTX1 and CTX2.
2192 : : Return 0 if CTX1 is equal to CTX2,
2193 : : -1 if CTX1 is a strict subset of CTX2,
2194 : : 1 if CTX2 is a strict subset of CTX1, or
2195 : : 2 if neither context is a subset of another one. */
2196 : :
2197 : : static int
2198 : 396 : omp_context_selector_compare (tree ctx1, tree ctx2)
2199 : : {
2200 : 396 : bool swapped = false;
2201 : 396 : int ret = 0;
2202 : 396 : int len1 = list_length (ctx1);
2203 : 396 : int len2 = list_length (ctx2);
2204 : 396 : int cnt = 0;
2205 : 396 : if (len1 < len2)
2206 : : {
2207 : 60 : swapped = true;
2208 : 60 : std::swap (ctx1, ctx2);
2209 : 60 : std::swap (len1, len2);
2210 : : }
2211 : 714 : for (tree tss1 = ctx1; tss1; tss1 = TREE_CHAIN (tss1))
2212 : : {
2213 : 514 : enum omp_tss_code set = OMP_TSS_CODE (tss1);
2214 : 514 : tree tss2;
2215 : 759 : for (tss2 = ctx2; tss2; tss2 = TREE_CHAIN (tss2))
2216 : 524 : if (set == OMP_TSS_CODE (tss2))
2217 : : {
2218 : 279 : int r
2219 : : = omp_context_selector_set_compare
2220 : 558 : (set, OMP_TSS_TRAIT_SELECTORS (tss1),
2221 : 279 : OMP_TSS_TRAIT_SELECTORS (tss2));
2222 : 279 : if (r == 2 || (ret && r && (ret < 0) != (r < 0)))
2223 : : return 2;
2224 : 98 : if (ret == 0)
2225 : 93 : ret = r;
2226 : 98 : cnt++;
2227 : 98 : break;
2228 : : }
2229 : 333 : if (tss2 == NULL_TREE)
2230 : : {
2231 : 235 : if (ret == -1)
2232 : : return 2;
2233 : : ret = 1;
2234 : : }
2235 : : }
2236 : 200 : if (cnt < len2)
2237 : : return 2;
2238 : 78 : if (ret == 0)
2239 : : return 0;
2240 : 63 : return swapped ? -ret : ret;
2241 : : }
2242 : :
2243 : : /* From context selector CTX, return trait-selector with name SEL in
2244 : : trait-selector-set with name SET if any, or NULL_TREE if not found. */
2245 : : tree
2246 : 2222 : omp_get_context_selector (tree ctx, enum omp_tss_code set,
2247 : : enum omp_ts_code sel)
2248 : : {
2249 : 4697 : for (tree tss = ctx; tss; tss = TREE_CHAIN (tss))
2250 : 2685 : if (OMP_TSS_CODE (tss) == set)
2251 : 1736 : for (tree ts = OMP_TSS_TRAIT_SELECTORS (tss); ts; ts = TREE_CHAIN (ts))
2252 : 1135 : if (OMP_TS_CODE (ts) == sel)
2253 : 210 : return ts;
2254 : : return NULL_TREE;
2255 : : }
2256 : :
2257 : : /* Similar, but returns the whole trait-selector list for SET in CTX. */
2258 : : tree
2259 : 1542 : omp_get_context_selector_list (tree ctx, enum omp_tss_code set)
2260 : : {
2261 : 2802 : for (tree tss = ctx; tss; tss = TREE_CHAIN (tss))
2262 : 1707 : if (OMP_TSS_CODE (tss) == set)
2263 : 447 : return OMP_TSS_TRAIT_SELECTORS (tss);
2264 : : return NULL_TREE;
2265 : : }
2266 : :
2267 : : /* Map string S onto a trait selector set code. */
2268 : : enum omp_tss_code
2269 : 1971 : omp_lookup_tss_code (const char * s)
2270 : : {
2271 : 5808 : for (int i = 0; i < OMP_TRAIT_SET_LAST; i++)
2272 : 5785 : if (strcmp (s, omp_tss_map[i]) == 0)
2273 : 1948 : return (enum omp_tss_code) i;
2274 : : return OMP_TRAIT_SET_INVALID;
2275 : : }
2276 : :
2277 : : /* Map string S onto a trait selector code for set SET. */
2278 : : enum omp_ts_code
2279 : 2398 : omp_lookup_ts_code (enum omp_tss_code set, const char *s)
2280 : : {
2281 : 2398 : unsigned int mask = 1 << set;
2282 : 25408 : for (int i = 0; i < OMP_TRAIT_LAST; i++)
2283 : 25319 : if ((mask & omp_ts_map[i].tss_mask) != 0
2284 : 5692 : && strcmp (s, omp_ts_map[i].name) == 0)
2285 : 2309 : return (enum omp_ts_code) i;
2286 : : return OMP_TRAIT_INVALID;
2287 : : }
2288 : :
2289 : : /* Needs to be a GC-friendly widest_int variant, but precision is
2290 : : desirable to be the same on all targets. */
2291 : : typedef generic_wide_int <fixed_wide_int_storage <1024> > score_wide_int;
2292 : :
2293 : : /* Compute *SCORE for context selector CTX. Return true if the score
2294 : : would be different depending on whether it is a declare simd clone or
2295 : : not. DECLARE_SIMD should be true for the case when it would be
2296 : : a declare simd clone. */
2297 : :
2298 : : static bool
2299 : 257 : omp_context_compute_score (tree ctx, score_wide_int *score, bool declare_simd)
2300 : : {
2301 : 257 : tree selectors
2302 : 257 : = omp_get_context_selector_list (ctx, OMP_TRAIT_SET_CONSTRUCT);
2303 : 257 : bool has_kind = omp_get_context_selector (ctx, OMP_TRAIT_SET_DEVICE,
2304 : 257 : OMP_TRAIT_DEVICE_KIND);
2305 : 257 : bool has_arch = omp_get_context_selector (ctx, OMP_TRAIT_SET_DEVICE,
2306 : 257 : OMP_TRAIT_DEVICE_ARCH);
2307 : 257 : bool has_isa = omp_get_context_selector (ctx, OMP_TRAIT_SET_DEVICE,
2308 : 257 : OMP_TRAIT_DEVICE_ISA);
2309 : 257 : bool ret = false;
2310 : 257 : *score = 1;
2311 : 602 : for (tree tss = ctx; tss; tss = TREE_CHAIN (tss))
2312 : 345 : if (OMP_TSS_TRAIT_SELECTORS (tss) != selectors)
2313 : 580 : for (tree ts = OMP_TSS_TRAIT_SELECTORS (tss); ts; ts = TREE_CHAIN (ts))
2314 : : {
2315 : 443 : tree s = OMP_TS_SCORE (ts);
2316 : 153 : if (s && TREE_CODE (s) == INTEGER_CST)
2317 : 306 : *score += score_wide_int::from (wi::to_wide (s),
2318 : 306 : TYPE_SIGN (TREE_TYPE (s)));
2319 : : }
2320 : :
2321 : 257 : if (selectors || has_kind || has_arch || has_isa)
2322 : : {
2323 : 177 : int nconstructs = list_length (selectors);
2324 : 177 : enum tree_code *constructs = NULL;
2325 : 177 : if (nconstructs)
2326 : : {
2327 : 55 : constructs
2328 : 55 : = (enum tree_code *) alloca (nconstructs
2329 : : * sizeof (enum tree_code));
2330 : 55 : omp_construct_traits_to_codes (selectors, nconstructs, constructs);
2331 : : }
2332 : 177 : int *scores
2333 : 177 : = (int *) alloca ((2 * nconstructs + 2) * sizeof (int));
2334 : 177 : if (omp_construct_selector_matches (constructs, nconstructs, scores)
2335 : : == 2)
2336 : 102 : ret = true;
2337 : 177 : int b = declare_simd ? nconstructs + 1 : 0;
2338 : 177 : if (scores[b + nconstructs] + 4U < score->get_precision ())
2339 : : {
2340 : 286 : for (int n = 0; n < nconstructs; ++n)
2341 : : {
2342 : 109 : if (scores[b + n] < 0)
2343 : : {
2344 : 0 : *score = -1;
2345 : 0 : return ret;
2346 : : }
2347 : 109 : *score += wi::shifted_mask <score_wide_int> (scores[b + n], 1, false);
2348 : : }
2349 : 177 : if (has_kind)
2350 : 136 : *score += wi::shifted_mask <score_wide_int> (scores[b + nconstructs],
2351 : 68 : 1, false);
2352 : 177 : if (has_arch)
2353 : 10 : *score += wi::shifted_mask <score_wide_int> (scores[b + nconstructs] + 1,
2354 : 5 : 1, false);
2355 : 177 : if (has_isa)
2356 : 98 : *score += wi::shifted_mask <score_wide_int> (scores[b + nconstructs] + 2,
2357 : 49 : 1, false);
2358 : : }
2359 : : else /* FIXME: Implement this. */
2360 : 0 : gcc_unreachable ();
2361 : : }
2362 : : return ret;
2363 : : }
2364 : :
2365 : : /* Class describing a single variant. */
2366 : 82 : struct GTY(()) omp_declare_variant_entry {
2367 : : /* NODE of the variant. */
2368 : : cgraph_node *variant;
2369 : : /* Score if not in declare simd clone. */
2370 : : score_wide_int score;
2371 : : /* Score if in declare simd clone. */
2372 : : score_wide_int score_in_declare_simd_clone;
2373 : : /* Context selector for the variant. */
2374 : : tree ctx;
2375 : : /* True if the context selector is known to match already. */
2376 : : bool matches;
2377 : : };
2378 : :
2379 : : /* Class describing a function with variants. */
2380 : : struct GTY((for_user)) omp_declare_variant_base_entry {
2381 : : /* NODE of the base function. */
2382 : : cgraph_node *base;
2383 : : /* NODE of the artificial function created for the deferred variant
2384 : : resolution. */
2385 : : cgraph_node *node;
2386 : : /* Vector of the variants. */
2387 : : vec<omp_declare_variant_entry, va_gc> *variants;
2388 : : };
2389 : :
2390 : : struct omp_declare_variant_hasher
2391 : : : ggc_ptr_hash<omp_declare_variant_base_entry> {
2392 : : static hashval_t hash (omp_declare_variant_base_entry *);
2393 : : static bool equal (omp_declare_variant_base_entry *,
2394 : : omp_declare_variant_base_entry *);
2395 : : };
2396 : :
2397 : : hashval_t
2398 : 24 : omp_declare_variant_hasher::hash (omp_declare_variant_base_entry *x)
2399 : : {
2400 : 24 : inchash::hash hstate;
2401 : 24 : hstate.add_int (DECL_UID (x->base->decl));
2402 : 24 : hstate.add_int (x->variants->length ());
2403 : 24 : omp_declare_variant_entry *variant;
2404 : 24 : unsigned int i;
2405 : 80 : FOR_EACH_VEC_SAFE_ELT (x->variants, i, variant)
2406 : : {
2407 : 56 : hstate.add_int (DECL_UID (variant->variant->decl));
2408 : 56 : hstate.add_wide_int (variant->score);
2409 : 56 : hstate.add_wide_int (variant->score_in_declare_simd_clone);
2410 : 56 : hstate.add_ptr (variant->ctx);
2411 : 56 : hstate.add_int (variant->matches);
2412 : : }
2413 : 24 : return hstate.end ();
2414 : : }
2415 : :
2416 : : bool
2417 : 10 : omp_declare_variant_hasher::equal (omp_declare_variant_base_entry *x,
2418 : : omp_declare_variant_base_entry *y)
2419 : : {
2420 : 10 : if (x->base != y->base
2421 : 10 : || x->variants->length () != y->variants->length ())
2422 : : return false;
2423 : : omp_declare_variant_entry *variant;
2424 : : unsigned int i;
2425 : 36 : FOR_EACH_VEC_SAFE_ELT (x->variants, i, variant)
2426 : 26 : if (variant->variant != (*y->variants)[i].variant
2427 : 26 : || variant->score != (*y->variants)[i].score
2428 : 52 : || (variant->score_in_declare_simd_clone
2429 : 26 : != (*y->variants)[i].score_in_declare_simd_clone)
2430 : 26 : || variant->ctx != (*y->variants)[i].ctx
2431 : 52 : || variant->matches != (*y->variants)[i].matches)
2432 : : return false;
2433 : : return true;
2434 : : }
2435 : :
2436 : : static GTY(()) hash_table<omp_declare_variant_hasher> *omp_declare_variants;
2437 : :
2438 : : struct omp_declare_variant_alt_hasher
2439 : : : ggc_ptr_hash<omp_declare_variant_base_entry> {
2440 : : static hashval_t hash (omp_declare_variant_base_entry *);
2441 : : static bool equal (omp_declare_variant_base_entry *,
2442 : : omp_declare_variant_base_entry *);
2443 : : };
2444 : :
2445 : : hashval_t
2446 : 0 : omp_declare_variant_alt_hasher::hash (omp_declare_variant_base_entry *x)
2447 : : {
2448 : 0 : return DECL_UID (x->node->decl);
2449 : : }
2450 : :
2451 : : bool
2452 : 121 : omp_declare_variant_alt_hasher::equal (omp_declare_variant_base_entry *x,
2453 : : omp_declare_variant_base_entry *y)
2454 : : {
2455 : 121 : return x->node == y->node;
2456 : : }
2457 : :
2458 : : static GTY(()) hash_table<omp_declare_variant_alt_hasher>
2459 : : *omp_declare_variant_alt;
2460 : :
2461 : : /* Try to resolve declare variant after gimplification. */
2462 : :
2463 : : static tree
2464 : 145 : omp_resolve_late_declare_variant (tree alt)
2465 : : {
2466 : 145 : cgraph_node *node = cgraph_node::get (alt);
2467 : 145 : cgraph_node *cur_node = cgraph_node::get (cfun->decl);
2468 : 145 : if (node == NULL
2469 : 145 : || !node->declare_variant_alt
2470 : 117 : || !cfun->after_inlining)
2471 : : return alt;
2472 : :
2473 : 117 : omp_declare_variant_base_entry entry;
2474 : 117 : entry.base = NULL;
2475 : 117 : entry.node = node;
2476 : 117 : entry.variants = NULL;
2477 : 117 : omp_declare_variant_base_entry *entryp
2478 : 117 : = omp_declare_variant_alt->find_with_hash (&entry, DECL_UID (alt));
2479 : :
2480 : 117 : unsigned int i, j;
2481 : 117 : omp_declare_variant_entry *varentry1, *varentry2;
2482 : 117 : auto_vec <bool, 16> matches;
2483 : 117 : unsigned int nmatches = 0;
2484 : 441 : FOR_EACH_VEC_SAFE_ELT (entryp->variants, i, varentry1)
2485 : : {
2486 : 333 : if (varentry1->matches)
2487 : : {
2488 : : /* This has been checked to be ok already. */
2489 : 216 : matches.safe_push (true);
2490 : 216 : nmatches++;
2491 : 216 : continue;
2492 : : }
2493 : 117 : switch (omp_context_selector_matches (varentry1->ctx))
2494 : : {
2495 : 84 : case 0:
2496 : 84 : matches.safe_push (false);
2497 : 84 : break;
2498 : : case -1:
2499 : : return alt;
2500 : 24 : default:
2501 : 24 : matches.safe_push (true);
2502 : 24 : nmatches++;
2503 : 24 : break;
2504 : : }
2505 : : }
2506 : :
2507 : 108 : if (nmatches == 0)
2508 : 0 : return entryp->base->decl;
2509 : :
2510 : : /* A context selector that is a strict subset of another context selector
2511 : : has a score of zero. */
2512 : 432 : FOR_EACH_VEC_SAFE_ELT (entryp->variants, i, varentry1)
2513 : 324 : if (matches[i])
2514 : : {
2515 : 480 : for (j = i + 1;
2516 : 804 : vec_safe_iterate (entryp->variants, j, &varentry2); ++j)
2517 : 240 : if (matches[j])
2518 : : {
2519 : 156 : int r = omp_context_selector_compare (varentry1->ctx,
2520 : : varentry2->ctx);
2521 : 156 : if (r == -1)
2522 : : {
2523 : : /* ctx1 is a strict subset of ctx2, ignore ctx1. */
2524 : 0 : matches[i] = false;
2525 : 0 : break;
2526 : : }
2527 : 156 : else if (r == 1)
2528 : : /* ctx2 is a strict subset of ctx1, remove ctx2. */
2529 : 0 : matches[j] = false;
2530 : : }
2531 : : }
2532 : :
2533 : 108 : score_wide_int max_score = -1;
2534 : 108 : varentry2 = NULL;
2535 : 432 : FOR_EACH_VEC_SAFE_ELT (entryp->variants, i, varentry1)
2536 : 324 : if (matches[i])
2537 : : {
2538 : 480 : score_wide_int score
2539 : 240 : = (cur_node->simdclone ? varentry1->score_in_declare_simd_clone
2540 : : : varentry1->score);
2541 : 240 : if (score > max_score)
2542 : : {
2543 : 162 : max_score = score;
2544 : 162 : varentry2 = varentry1;
2545 : : }
2546 : : }
2547 : 108 : return varentry2->variant->decl;
2548 : 117 : }
2549 : :
2550 : : /* Hook to adjust hash tables on cgraph_node removal. */
2551 : :
2552 : : static void
2553 : 15 : omp_declare_variant_remove_hook (struct cgraph_node *node, void *)
2554 : : {
2555 : 15 : if (!node->declare_variant_alt)
2556 : : return;
2557 : :
2558 : : /* Drop this hash table completely. */
2559 : 2 : omp_declare_variants = NULL;
2560 : : /* And remove node from the other hash table. */
2561 : 2 : if (omp_declare_variant_alt)
2562 : : {
2563 : 2 : omp_declare_variant_base_entry entry;
2564 : 2 : entry.base = NULL;
2565 : 2 : entry.node = node;
2566 : 2 : entry.variants = NULL;
2567 : 2 : omp_declare_variant_alt->remove_elt_with_hash (&entry,
2568 : 2 : DECL_UID (node->decl));
2569 : : }
2570 : : }
2571 : :
2572 : : /* Try to resolve declare variant, return the variant decl if it should
2573 : : be used instead of base, or base otherwise. */
2574 : :
2575 : : tree
2576 : 194845 : omp_resolve_declare_variant (tree base)
2577 : : {
2578 : 194845 : tree variant1 = NULL_TREE, variant2 = NULL_TREE;
2579 : 194845 : if (cfun && (cfun->curr_properties & PROP_gimple_any) != 0)
2580 : 145 : return omp_resolve_late_declare_variant (base);
2581 : :
2582 : 194700 : auto_vec <tree, 16> variants;
2583 : 194700 : auto_vec <bool, 16> defer;
2584 : 194700 : bool any_deferred = false;
2585 : 195249 : for (tree attr = DECL_ATTRIBUTES (base); attr; attr = TREE_CHAIN (attr))
2586 : : {
2587 : 99021 : attr = lookup_attribute ("omp declare variant base", attr);
2588 : 99021 : if (attr == NULL_TREE)
2589 : : break;
2590 : 585 : if (TREE_CODE (TREE_PURPOSE (TREE_VALUE (attr))) != FUNCTION_DECL)
2591 : 0 : continue;
2592 : 585 : cgraph_node *node = cgraph_node::get (base);
2593 : : /* If this is already a magic decl created by this function,
2594 : : don't process it again. */
2595 : 585 : if (node && node->declare_variant_alt)
2596 : 36 : return base;
2597 : 549 : switch (omp_context_selector_matches (TREE_VALUE (TREE_VALUE (attr))))
2598 : : {
2599 : : case 0:
2600 : : /* No match, ignore. */
2601 : : break;
2602 : 37 : case -1:
2603 : : /* Needs to be deferred. */
2604 : 37 : any_deferred = true;
2605 : 37 : variants.safe_push (attr);
2606 : 37 : defer.safe_push (true);
2607 : 37 : break;
2608 : 384 : default:
2609 : 384 : variants.safe_push (attr);
2610 : 384 : defer.safe_push (false);
2611 : 384 : break;
2612 : : }
2613 : : }
2614 : 194700 : if (variants.length () == 0)
2615 : : return base;
2616 : :
2617 : 221 : if (any_deferred)
2618 : : {
2619 : 29 : score_wide_int max_score1 = 0;
2620 : 29 : score_wide_int max_score2 = 0;
2621 : 29 : bool first = true;
2622 : 29 : unsigned int i;
2623 : 29 : tree attr1, attr2;
2624 : 29 : omp_declare_variant_base_entry entry;
2625 : 29 : entry.base = cgraph_node::get_create (base);
2626 : 29 : entry.node = NULL;
2627 : 58 : vec_alloc (entry.variants, variants.length ());
2628 : 105 : FOR_EACH_VEC_ELT (variants, i, attr1)
2629 : : {
2630 : 76 : score_wide_int score1;
2631 : 76 : score_wide_int score2;
2632 : 76 : bool need_two;
2633 : 76 : tree ctx = TREE_VALUE (TREE_VALUE (attr1));
2634 : 76 : need_two = omp_context_compute_score (ctx, &score1, false);
2635 : 76 : if (need_two)
2636 : 51 : omp_context_compute_score (ctx, &score2, true);
2637 : : else
2638 : 25 : score2 = score1;
2639 : 76 : if (first)
2640 : : {
2641 : 29 : first = false;
2642 : 29 : max_score1 = score1;
2643 : 29 : max_score2 = score2;
2644 : 29 : if (!defer[i])
2645 : : {
2646 : 8 : variant1 = attr1;
2647 : 8 : variant2 = attr1;
2648 : : }
2649 : : }
2650 : : else
2651 : : {
2652 : 47 : if (max_score1 == score1)
2653 : : variant1 = NULL_TREE;
2654 : 38 : else if (score1 > max_score1)
2655 : : {
2656 : 19 : max_score1 = score1;
2657 : 19 : variant1 = defer[i] ? NULL_TREE : attr1;
2658 : : }
2659 : 47 : if (max_score2 == score2)
2660 : : variant2 = NULL_TREE;
2661 : 47 : else if (score2 > max_score2)
2662 : : {
2663 : 19 : max_score2 = score2;
2664 : 19 : variant2 = defer[i] ? NULL_TREE : attr1;
2665 : : }
2666 : : }
2667 : 76 : omp_declare_variant_entry varentry;
2668 : 76 : varentry.variant
2669 : 76 : = cgraph_node::get_create (TREE_PURPOSE (TREE_VALUE (attr1)));
2670 : 76 : varentry.score = score1;
2671 : 76 : varentry.score_in_declare_simd_clone = score2;
2672 : 76 : varentry.ctx = ctx;
2673 : 76 : varentry.matches = !defer[i];
2674 : 76 : entry.variants->quick_push (varentry);
2675 : : }
2676 : :
2677 : : /* If there is a clear winner variant with the score which is not
2678 : : deferred, verify it is not a strict subset of any other context
2679 : : selector and if it is not, it is the best alternative no matter
2680 : : whether the others do or don't match. */
2681 : 29 : if (variant1 && variant1 == variant2)
2682 : : {
2683 : 5 : tree ctx1 = TREE_VALUE (TREE_VALUE (variant1));
2684 : 25 : FOR_EACH_VEC_ELT (variants, i, attr2)
2685 : : {
2686 : 20 : if (attr2 == variant1)
2687 : 5 : continue;
2688 : 15 : tree ctx2 = TREE_VALUE (TREE_VALUE (attr2));
2689 : 15 : int r = omp_context_selector_compare (ctx1, ctx2);
2690 : 15 : if (r == -1)
2691 : : {
2692 : : /* The winner is a strict subset of ctx2, can't
2693 : : decide now. */
2694 : : variant1 = NULL_TREE;
2695 : : break;
2696 : : }
2697 : : }
2698 : 5 : if (variant1)
2699 : : {
2700 : 5 : vec_free (entry.variants);
2701 : 5 : return TREE_PURPOSE (TREE_VALUE (variant1));
2702 : : }
2703 : : }
2704 : :
2705 : 24 : static struct cgraph_node_hook_list *node_removal_hook_holder;
2706 : 24 : if (!node_removal_hook_holder)
2707 : 10 : node_removal_hook_holder
2708 : 10 : = symtab->add_cgraph_removal_hook (omp_declare_variant_remove_hook,
2709 : : NULL);
2710 : :
2711 : 24 : if (omp_declare_variants == NULL)
2712 : 10 : omp_declare_variants
2713 : 10 : = hash_table<omp_declare_variant_hasher>::create_ggc (64);
2714 : 24 : omp_declare_variant_base_entry **slot
2715 : 24 : = omp_declare_variants->find_slot (&entry, INSERT);
2716 : 24 : if (*slot != NULL)
2717 : : {
2718 : 10 : vec_free (entry.variants);
2719 : 10 : return (*slot)->node->decl;
2720 : : }
2721 : :
2722 : 14 : *slot = ggc_cleared_alloc<omp_declare_variant_base_entry> ();
2723 : 14 : (*slot)->base = entry.base;
2724 : 14 : (*slot)->node = entry.base;
2725 : 14 : (*slot)->variants = entry.variants;
2726 : 14 : tree alt = build_decl (DECL_SOURCE_LOCATION (base), FUNCTION_DECL,
2727 : 14 : DECL_NAME (base), TREE_TYPE (base));
2728 : 14 : DECL_ARTIFICIAL (alt) = 1;
2729 : 14 : DECL_IGNORED_P (alt) = 1;
2730 : 14 : TREE_STATIC (alt) = 1;
2731 : 14 : tree attributes = DECL_ATTRIBUTES (base);
2732 : 14 : if (lookup_attribute ("noipa", attributes) == NULL)
2733 : : {
2734 : 14 : attributes = tree_cons (get_identifier ("noipa"), NULL, attributes);
2735 : 14 : if (lookup_attribute ("noinline", attributes) == NULL)
2736 : 14 : attributes = tree_cons (get_identifier ("noinline"), NULL,
2737 : : attributes);
2738 : 14 : if (lookup_attribute ("noclone", attributes) == NULL)
2739 : 14 : attributes = tree_cons (get_identifier ("noclone"), NULL,
2740 : : attributes);
2741 : 14 : if (lookup_attribute ("no_icf", attributes) == NULL)
2742 : 14 : attributes = tree_cons (get_identifier ("no_icf"), NULL,
2743 : : attributes);
2744 : : }
2745 : 14 : DECL_ATTRIBUTES (alt) = attributes;
2746 : 14 : DECL_INITIAL (alt) = error_mark_node;
2747 : 14 : (*slot)->node = cgraph_node::create (alt);
2748 : 14 : (*slot)->node->declare_variant_alt = 1;
2749 : 14 : (*slot)->node->create_reference (entry.base, IPA_REF_ADDR);
2750 : 14 : omp_declare_variant_entry *varentry;
2751 : 58 : FOR_EACH_VEC_SAFE_ELT (entry.variants, i, varentry)
2752 : 30 : (*slot)->node->create_reference (varentry->variant, IPA_REF_ADDR);
2753 : 14 : if (omp_declare_variant_alt == NULL)
2754 : 10 : omp_declare_variant_alt
2755 : 10 : = hash_table<omp_declare_variant_alt_hasher>::create_ggc (64);
2756 : 14 : *omp_declare_variant_alt->find_slot_with_hash (*slot, DECL_UID (alt),
2757 : 14 : INSERT) = *slot;
2758 : 14 : return alt;
2759 : : }
2760 : :
2761 : 192 : if (variants.length () == 1)
2762 : 114 : return TREE_PURPOSE (TREE_VALUE (variants[0]));
2763 : :
2764 : : /* A context selector that is a strict subset of another context selector
2765 : : has a score of zero. */
2766 : : tree attr1, attr2;
2767 : : unsigned int i, j;
2768 : 309 : FOR_EACH_VEC_ELT (variants, i, attr1)
2769 : 231 : if (attr1)
2770 : : {
2771 : 199 : tree ctx1 = TREE_VALUE (TREE_VALUE (attr1));
2772 : 624 : FOR_EACH_VEC_ELT_FROM (variants, j, attr2, i + 1)
2773 : 225 : if (attr2)
2774 : : {
2775 : 225 : tree ctx2 = TREE_VALUE (TREE_VALUE (attr2));
2776 : 225 : int r = omp_context_selector_compare (ctx1, ctx2);
2777 : 225 : if (r == -1)
2778 : : {
2779 : : /* ctx1 is a strict subset of ctx2, remove
2780 : : attr1 from the vector. */
2781 : 31 : variants[i] = NULL_TREE;
2782 : 31 : break;
2783 : : }
2784 : 194 : else if (r == 1)
2785 : : /* ctx2 is a strict subset of ctx1, remove attr2
2786 : : from the vector. */
2787 : 32 : variants[j] = NULL_TREE;
2788 : : }
2789 : : }
2790 : 78 : score_wide_int max_score1 = 0;
2791 : 78 : score_wide_int max_score2 = 0;
2792 : 78 : bool first = true;
2793 : 309 : FOR_EACH_VEC_ELT (variants, i, attr1)
2794 : 231 : if (attr1)
2795 : : {
2796 : 168 : if (variant1)
2797 : : {
2798 : 90 : score_wide_int score1;
2799 : 90 : score_wide_int score2;
2800 : 90 : bool need_two;
2801 : 90 : tree ctx;
2802 : 90 : if (first)
2803 : : {
2804 : 40 : first = false;
2805 : 40 : ctx = TREE_VALUE (TREE_VALUE (variant1));
2806 : 40 : need_two = omp_context_compute_score (ctx, &max_score1, false);
2807 : 40 : if (need_two)
2808 : 0 : omp_context_compute_score (ctx, &max_score2, true);
2809 : : else
2810 : 40 : max_score2 = max_score1;
2811 : : }
2812 : 90 : ctx = TREE_VALUE (TREE_VALUE (attr1));
2813 : 90 : need_two = omp_context_compute_score (ctx, &score1, false);
2814 : 90 : if (need_two)
2815 : 0 : omp_context_compute_score (ctx, &score2, true);
2816 : : else
2817 : 90 : score2 = score1;
2818 : 90 : if (score1 > max_score1)
2819 : : {
2820 : 35 : max_score1 = score1;
2821 : 35 : variant1 = attr1;
2822 : : }
2823 : 90 : if (score2 > max_score2)
2824 : : {
2825 : 35 : max_score2 = score2;
2826 : 35 : variant2 = attr1;
2827 : : }
2828 : : }
2829 : : else
2830 : : {
2831 : : variant1 = attr1;
2832 : : variant2 = attr1;
2833 : : }
2834 : : }
2835 : : /* If there is a disagreement on which variant has the highest score
2836 : : depending on whether it will be in a declare simd clone or not,
2837 : : punt for now and defer until after IPA where we will know that. */
2838 : 78 : return ((variant1 && variant1 == variant2)
2839 : 156 : ? TREE_PURPOSE (TREE_VALUE (variant1)) : base);
2840 : 194700 : }
2841 : :
2842 : : void
2843 : 2 : omp_lto_output_declare_variant_alt (lto_simple_output_block *ob,
2844 : : cgraph_node *node,
2845 : : lto_symtab_encoder_t encoder)
2846 : : {
2847 : 2 : gcc_assert (node->declare_variant_alt);
2848 : :
2849 : 2 : omp_declare_variant_base_entry entry;
2850 : 2 : entry.base = NULL;
2851 : 2 : entry.node = node;
2852 : 2 : entry.variants = NULL;
2853 : 2 : omp_declare_variant_base_entry *entryp
2854 : 2 : = omp_declare_variant_alt->find_with_hash (&entry, DECL_UID (node->decl));
2855 : 2 : gcc_assert (entryp);
2856 : :
2857 : 2 : int nbase = lto_symtab_encoder_lookup (encoder, entryp->base);
2858 : 2 : gcc_assert (nbase != LCC_NOT_FOUND);
2859 : 2 : streamer_write_hwi_stream (ob->main_stream, nbase);
2860 : :
2861 : 2 : streamer_write_hwi_stream (ob->main_stream, entryp->variants->length ());
2862 : :
2863 : 2 : unsigned int i;
2864 : 2 : omp_declare_variant_entry *varentry;
2865 : 8 : FOR_EACH_VEC_SAFE_ELT (entryp->variants, i, varentry)
2866 : : {
2867 : 6 : int nvar = lto_symtab_encoder_lookup (encoder, varentry->variant);
2868 : 6 : gcc_assert (nvar != LCC_NOT_FOUND);
2869 : 6 : streamer_write_hwi_stream (ob->main_stream, nvar);
2870 : :
2871 : 6 : for (score_wide_int *w = &varentry->score; ;
2872 : : w = &varentry->score_in_declare_simd_clone)
2873 : : {
2874 : 12 : unsigned len = w->get_len ();
2875 : 12 : streamer_write_hwi_stream (ob->main_stream, len);
2876 : 12 : const HOST_WIDE_INT *val = w->get_val ();
2877 : 24 : for (unsigned j = 0; j < len; j++)
2878 : 12 : streamer_write_hwi_stream (ob->main_stream, val[j]);
2879 : 12 : if (w == &varentry->score_in_declare_simd_clone)
2880 : : break;
2881 : : }
2882 : :
2883 : 6 : HOST_WIDE_INT cnt = -1;
2884 : 6 : HOST_WIDE_INT i = varentry->matches ? 1 : 0;
2885 : 6 : for (tree attr = DECL_ATTRIBUTES (entryp->base->decl);
2886 : 12 : attr; attr = TREE_CHAIN (attr), i += 2)
2887 : : {
2888 : 12 : attr = lookup_attribute ("omp declare variant base", attr);
2889 : 12 : if (attr == NULL_TREE)
2890 : : break;
2891 : :
2892 : 12 : if (varentry->ctx == TREE_VALUE (TREE_VALUE (attr)))
2893 : : {
2894 : : cnt = i;
2895 : : break;
2896 : : }
2897 : : }
2898 : :
2899 : 6 : gcc_assert (cnt != -1);
2900 : 6 : streamer_write_hwi_stream (ob->main_stream, cnt);
2901 : : }
2902 : 2 : }
2903 : :
2904 : : void
2905 : 2 : omp_lto_input_declare_variant_alt (lto_input_block *ib, cgraph_node *node,
2906 : : vec<symtab_node *> nodes)
2907 : : {
2908 : 2 : gcc_assert (node->declare_variant_alt);
2909 : 2 : omp_declare_variant_base_entry *entryp
2910 : 2 : = ggc_cleared_alloc<omp_declare_variant_base_entry> ();
2911 : 2 : entryp->base = dyn_cast<cgraph_node *> (nodes[streamer_read_hwi (ib)]);
2912 : 2 : entryp->node = node;
2913 : 2 : unsigned int len = streamer_read_hwi (ib);
2914 : 2 : vec_alloc (entryp->variants, len);
2915 : :
2916 : 8 : for (unsigned int i = 0; i < len; i++)
2917 : : {
2918 : 6 : omp_declare_variant_entry varentry;
2919 : 6 : varentry.variant
2920 : 6 : = dyn_cast<cgraph_node *> (nodes[streamer_read_hwi (ib)]);
2921 : 6 : for (score_wide_int *w = &varentry.score; ;
2922 : 6 : w = &varentry.score_in_declare_simd_clone)
2923 : : {
2924 : 12 : unsigned len2 = streamer_read_hwi (ib);
2925 : 12 : HOST_WIDE_INT arr[WIDE_INT_MAX_HWIS (1024)];
2926 : 12 : gcc_assert (len2 <= WIDE_INT_MAX_HWIS (1024));
2927 : 24 : for (unsigned int j = 0; j < len2; j++)
2928 : 12 : arr[j] = streamer_read_hwi (ib);
2929 : 12 : *w = score_wide_int::from_array (arr, len2, true);
2930 : 12 : if (w == &varentry.score_in_declare_simd_clone)
2931 : : break;
2932 : 6 : }
2933 : :
2934 : 6 : HOST_WIDE_INT cnt = streamer_read_hwi (ib);
2935 : 6 : HOST_WIDE_INT j = 0;
2936 : 6 : varentry.ctx = NULL_TREE;
2937 : 6 : varentry.matches = (cnt & 1) ? true : false;
2938 : 6 : cnt &= ~HOST_WIDE_INT_1;
2939 : 6 : for (tree attr = DECL_ATTRIBUTES (entryp->base->decl);
2940 : 12 : attr; attr = TREE_CHAIN (attr), j += 2)
2941 : : {
2942 : 12 : attr = lookup_attribute ("omp declare variant base", attr);
2943 : 12 : if (attr == NULL_TREE)
2944 : : break;
2945 : :
2946 : 12 : if (cnt == j)
2947 : : {
2948 : 6 : varentry.ctx = TREE_VALUE (TREE_VALUE (attr));
2949 : 6 : break;
2950 : : }
2951 : : }
2952 : 6 : gcc_assert (varentry.ctx != NULL_TREE);
2953 : 6 : entryp->variants->quick_push (varentry);
2954 : : }
2955 : 2 : if (omp_declare_variant_alt == NULL)
2956 : 2 : omp_declare_variant_alt
2957 : 2 : = hash_table<omp_declare_variant_alt_hasher>::create_ggc (64);
2958 : 2 : *omp_declare_variant_alt->find_slot_with_hash (entryp, DECL_UID (node->decl),
2959 : 2 : INSERT) = entryp;
2960 : 2 : }
2961 : :
2962 : : /* Encode an oacc launch argument. This matches the GOMP_LAUNCH_PACK
2963 : : macro on gomp-constants.h. We do not check for overflow. */
2964 : :
2965 : : tree
2966 : 10238 : oacc_launch_pack (unsigned code, tree device, unsigned op)
2967 : : {
2968 : 10238 : tree res;
2969 : :
2970 : 10238 : res = build_int_cst (unsigned_type_node, GOMP_LAUNCH_PACK (code, 0, op));
2971 : 10238 : if (device)
2972 : : {
2973 : 0 : device = fold_build2 (LSHIFT_EXPR, unsigned_type_node,
2974 : : device, build_int_cst (unsigned_type_node,
2975 : : GOMP_LAUNCH_DEVICE_SHIFT));
2976 : 0 : res = fold_build2 (BIT_IOR_EXPR, unsigned_type_node, res, device);
2977 : : }
2978 : 10238 : return res;
2979 : : }
2980 : :
2981 : : /* Openacc compute grid dimension clauses are converted to an attribute
2982 : : attached to the function. This permits the target-side code to (a) massage
2983 : : the dimensions, (b) emit that data and (c) optimize. Non-constant
2984 : : dimensions are pushed onto ARGS.
2985 : :
2986 : : The attribute value is a TREE_LIST. A set of dimensions is
2987 : : represented as a list of INTEGER_CST. Those that are runtime
2988 : : exprs are represented as an INTEGER_CST of zero.
2989 : :
2990 : : TODO: Normally the attribute will just contain a single such list. If
2991 : : however it contains a list of lists, this will represent the use of
2992 : : device_type. Each member of the outer list is an assoc list of
2993 : : dimensions, keyed by the device type. The first entry will be the
2994 : : default. Well, that's the plan. */
2995 : :
2996 : : /* Replace any existing oacc fn attribute in ATTRIBS with updated
2997 : : dimensions. */
2998 : :
2999 : : tree
3000 : 19561 : oacc_replace_fn_attrib_attr (tree attribs, tree dims)
3001 : : {
3002 : 19561 : tree ident = get_identifier (OACC_FN_ATTRIB);
3003 : :
3004 : : /* If we happen to be present as the first attrib, drop it. */
3005 : 38064 : if (attribs && TREE_PURPOSE (attribs) == ident)
3006 : 9390 : attribs = TREE_CHAIN (attribs);
3007 : 19561 : return tree_cons (ident, dims, attribs);
3008 : : }
3009 : :
3010 : : /* Replace any existing oacc fn attribute on FN with updated
3011 : : dimensions. */
3012 : :
3013 : : void
3014 : 19224 : oacc_replace_fn_attrib (tree fn, tree dims)
3015 : : {
3016 : 19224 : DECL_ATTRIBUTES (fn)
3017 : 19224 : = oacc_replace_fn_attrib_attr (DECL_ATTRIBUTES (fn), dims);
3018 : 19224 : }
3019 : :
3020 : : /* Scan CLAUSES for launch dimensions and attach them to the oacc
3021 : : function attribute. Push any that are non-constant onto the ARGS
3022 : : list, along with an appropriate GOMP_LAUNCH_DIM tag. */
3023 : :
3024 : : void
3025 : 9707 : oacc_set_fn_attrib (tree fn, tree clauses, vec<tree> *args)
3026 : : {
3027 : : /* Must match GOMP_DIM ordering. */
3028 : 9707 : static const omp_clause_code ids[]
3029 : : = { OMP_CLAUSE_NUM_GANGS, OMP_CLAUSE_NUM_WORKERS,
3030 : : OMP_CLAUSE_VECTOR_LENGTH };
3031 : 9707 : unsigned ix;
3032 : 9707 : tree dims[GOMP_DIM_MAX];
3033 : :
3034 : 9707 : tree attr = NULL_TREE;
3035 : 9707 : unsigned non_const = 0;
3036 : :
3037 : 38828 : for (ix = GOMP_DIM_MAX; ix--;)
3038 : : {
3039 : 29121 : tree clause = omp_find_clause (clauses, ids[ix]);
3040 : 29121 : tree dim = NULL_TREE;
3041 : :
3042 : 29121 : if (clause)
3043 : 3287 : dim = OMP_CLAUSE_EXPR (clause, ids[ix]);
3044 : 29121 : dims[ix] = dim;
3045 : 29121 : if (dim && TREE_CODE (dim) != INTEGER_CST)
3046 : : {
3047 : 157 : dim = integer_zero_node;
3048 : 157 : non_const |= GOMP_DIM_MASK (ix);
3049 : : }
3050 : 29121 : attr = tree_cons (NULL_TREE, dim, attr);
3051 : : }
3052 : :
3053 : 9707 : oacc_replace_fn_attrib (fn, attr);
3054 : :
3055 : 9707 : if (non_const)
3056 : : {
3057 : : /* Push a dynamic argument set. */
3058 : 101 : args->safe_push (oacc_launch_pack (GOMP_LAUNCH_DIM,
3059 : : NULL_TREE, non_const));
3060 : 404 : for (unsigned ix = 0; ix != GOMP_DIM_MAX; ix++)
3061 : 303 : if (non_const & GOMP_DIM_MASK (ix))
3062 : 157 : args->safe_push (dims[ix]);
3063 : : }
3064 : 9707 : }
3065 : :
3066 : : /* Verify OpenACC routine clauses.
3067 : :
3068 : : Returns 0 if FNDECL should be marked with an OpenACC 'routine' directive, 1
3069 : : if it has already been marked in compatible way, and -1 if incompatible.
3070 : : Upon returning, the chain of clauses will contain exactly one clause
3071 : : specifying the level of parallelism. */
3072 : :
3073 : : int
3074 : 1202 : oacc_verify_routine_clauses (tree fndecl, tree *clauses, location_t loc,
3075 : : const char *routine_str)
3076 : : {
3077 : 1202 : tree c_level = NULL_TREE;
3078 : 1202 : tree c_nohost = NULL_TREE;
3079 : 1202 : tree c_p = NULL_TREE;
3080 : 3618 : for (tree c = *clauses; c; c_p = c, c = OMP_CLAUSE_CHAIN (c))
3081 : 2416 : switch (OMP_CLAUSE_CODE (c))
3082 : : {
3083 : 2317 : case OMP_CLAUSE_GANG:
3084 : 2317 : case OMP_CLAUSE_WORKER:
3085 : 2317 : case OMP_CLAUSE_VECTOR:
3086 : 2317 : case OMP_CLAUSE_SEQ:
3087 : 2317 : if (c_level == NULL_TREE)
3088 : : c_level = c;
3089 : 1496 : else if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_CODE (c_level))
3090 : : {
3091 : : /* This has already been diagnosed in the front ends. */
3092 : : /* Drop the duplicate clause. */
3093 : 352 : gcc_checking_assert (c_p != NULL_TREE);
3094 : 352 : OMP_CLAUSE_CHAIN (c_p) = OMP_CLAUSE_CHAIN (c);
3095 : 352 : c = c_p;
3096 : : }
3097 : : else
3098 : : {
3099 : 1144 : error_at (OMP_CLAUSE_LOCATION (c),
3100 : : "%qs specifies a conflicting level of parallelism",
3101 : 1144 : omp_clause_code_name[OMP_CLAUSE_CODE (c)]);
3102 : 1144 : inform (OMP_CLAUSE_LOCATION (c_level),
3103 : : "... to the previous %qs clause here",
3104 : 1144 : omp_clause_code_name[OMP_CLAUSE_CODE (c_level)]);
3105 : : /* Drop the conflicting clause. */
3106 : 1144 : gcc_checking_assert (c_p != NULL_TREE);
3107 : 1144 : OMP_CLAUSE_CHAIN (c_p) = OMP_CLAUSE_CHAIN (c);
3108 : 1144 : c = c_p;
3109 : : }
3110 : : break;
3111 : : case OMP_CLAUSE_NOHOST:
3112 : : /* Don't worry about duplicate clauses here. */
3113 : : c_nohost = c;
3114 : : break;
3115 : 0 : default:
3116 : 0 : gcc_unreachable ();
3117 : : }
3118 : 1202 : if (c_level == NULL_TREE)
3119 : : {
3120 : : /* Default to an implicit 'seq' clause. */
3121 : 381 : c_level = build_omp_clause (loc, OMP_CLAUSE_SEQ);
3122 : 381 : OMP_CLAUSE_CHAIN (c_level) = *clauses;
3123 : 381 : *clauses = c_level;
3124 : : }
3125 : : /* In *clauses, we now have exactly one clause specifying the level of
3126 : : parallelism. */
3127 : :
3128 : 1202 : tree attr
3129 : 1202 : = lookup_attribute ("omp declare target", DECL_ATTRIBUTES (fndecl));
3130 : 1202 : if (attr != NULL_TREE)
3131 : : {
3132 : : /* Diagnose if "#pragma omp declare target" has also been applied. */
3133 : 429 : if (TREE_VALUE (attr) == NULL_TREE)
3134 : : {
3135 : : /* See <https://gcc.gnu.org/PR93465>; the semantics of combining
3136 : : OpenACC and OpenMP 'target' are not clear. */
3137 : 32 : error_at (loc,
3138 : : "cannot apply %<%s%> to %qD, which has also been"
3139 : : " marked with an OpenMP 'declare target' directive",
3140 : : routine_str, fndecl);
3141 : : /* Incompatible. */
3142 : 32 : return -1;
3143 : : }
3144 : :
3145 : : /* If a "#pragma acc routine" has already been applied, just verify
3146 : : this one for compatibility. */
3147 : : /* Collect previous directive's clauses. */
3148 : : tree c_level_p = NULL_TREE;
3149 : : tree c_nohost_p = NULL_TREE;
3150 : 850 : for (tree c = TREE_VALUE (attr); c; c = OMP_CLAUSE_CHAIN (c))
3151 : 453 : switch (OMP_CLAUSE_CODE (c))
3152 : : {
3153 : 397 : case OMP_CLAUSE_GANG:
3154 : 397 : case OMP_CLAUSE_WORKER:
3155 : 397 : case OMP_CLAUSE_VECTOR:
3156 : 397 : case OMP_CLAUSE_SEQ:
3157 : 397 : gcc_checking_assert (c_level_p == NULL_TREE);
3158 : : c_level_p = c;
3159 : : break;
3160 : 56 : case OMP_CLAUSE_NOHOST:
3161 : 56 : gcc_checking_assert (c_nohost_p == NULL_TREE);
3162 : : c_nohost_p = c;
3163 : : break;
3164 : 0 : default:
3165 : 0 : gcc_unreachable ();
3166 : : }
3167 : 397 : gcc_checking_assert (c_level_p != NULL_TREE);
3168 : : /* ..., and compare to current directive's, which we've already collected
3169 : : above. */
3170 : 397 : tree c_diag;
3171 : 397 : tree c_diag_p;
3172 : : /* Matching level of parallelism? */
3173 : 397 : if (OMP_CLAUSE_CODE (c_level) != OMP_CLAUSE_CODE (c_level_p))
3174 : : {
3175 : 97 : c_diag = c_level;
3176 : 97 : c_diag_p = c_level_p;
3177 : 97 : goto incompatible;
3178 : : }
3179 : : /* Matching 'nohost' clauses? */
3180 : 300 : if ((c_nohost == NULL_TREE) != (c_nohost_p == NULL_TREE))
3181 : : {
3182 : 56 : c_diag = c_nohost;
3183 : 56 : c_diag_p = c_nohost_p;
3184 : 56 : goto incompatible;
3185 : : }
3186 : : /* Compatible. */
3187 : : return 1;
3188 : :
3189 : 153 : incompatible:
3190 : 153 : if (c_diag != NULL_TREE)
3191 : 125 : error_at (OMP_CLAUSE_LOCATION (c_diag),
3192 : : "incompatible %qs clause when applying"
3193 : : " %<%s%> to %qD, which has already been"
3194 : : " marked with an OpenACC 'routine' directive",
3195 : 125 : omp_clause_code_name[OMP_CLAUSE_CODE (c_diag)],
3196 : : routine_str, fndecl);
3197 : 28 : else if (c_diag_p != NULL_TREE)
3198 : 28 : error_at (loc,
3199 : : "missing %qs clause when applying"
3200 : : " %<%s%> to %qD, which has already been"
3201 : : " marked with an OpenACC 'routine' directive",
3202 : 28 : omp_clause_code_name[OMP_CLAUSE_CODE (c_diag_p)],
3203 : : routine_str, fndecl);
3204 : : else
3205 : 0 : gcc_unreachable ();
3206 : 153 : if (c_diag_p != NULL_TREE)
3207 : 125 : inform (OMP_CLAUSE_LOCATION (c_diag_p),
3208 : : "... with %qs clause here",
3209 : 125 : omp_clause_code_name[OMP_CLAUSE_CODE (c_diag_p)]);
3210 : : else
3211 : : {
3212 : : /* In the front ends, we don't preserve location information for the
3213 : : OpenACC routine directive itself. However, that of c_level_p
3214 : : should be close. */
3215 : 28 : location_t loc_routine = OMP_CLAUSE_LOCATION (c_level_p);
3216 : 28 : inform (loc_routine, "... without %qs clause near to here",
3217 : 28 : omp_clause_code_name[OMP_CLAUSE_CODE (c_diag)]);
3218 : : }
3219 : : /* Incompatible. */
3220 : 153 : return -1;
3221 : : }
3222 : :
3223 : : return 0;
3224 : : }
3225 : :
3226 : : /* Process the OpenACC 'routine' directive clauses to generate an attribute
3227 : : for the level of parallelism. All dimensions have a size of zero
3228 : : (dynamic). TREE_PURPOSE is set to indicate whether that dimension
3229 : : can have a loop partitioned on it. non-zero indicates
3230 : : yes, zero indicates no. By construction once a non-zero has been
3231 : : reached, further inner dimensions must also be non-zero. We set
3232 : : TREE_VALUE to zero for the dimensions that may be partitioned and
3233 : : 1 for the other ones -- if a loop is (erroneously) spawned at
3234 : : an outer level, we don't want to try and partition it. */
3235 : :
3236 : : tree
3237 : 1102 : oacc_build_routine_dims (tree clauses)
3238 : : {
3239 : : /* Must match GOMP_DIM ordering. */
3240 : 1102 : static const omp_clause_code ids[]
3241 : : = {OMP_CLAUSE_GANG, OMP_CLAUSE_WORKER, OMP_CLAUSE_VECTOR, OMP_CLAUSE_SEQ};
3242 : 1102 : int ix;
3243 : 1102 : int level = -1;
3244 : :
3245 : 2247 : for (; clauses; clauses = OMP_CLAUSE_CHAIN (clauses))
3246 : 2249 : for (ix = GOMP_DIM_MAX + 1; ix--;)
3247 : 2206 : if (OMP_CLAUSE_CODE (clauses) == ids[ix])
3248 : : {
3249 : : level = ix;
3250 : : break;
3251 : : }
3252 : 1102 : gcc_checking_assert (level >= 0);
3253 : :
3254 : : tree dims = NULL_TREE;
3255 : :
3256 : 4408 : for (ix = GOMP_DIM_MAX; ix--;)
3257 : 3306 : dims = tree_cons (build_int_cst (boolean_type_node, ix >= level),
3258 : 3306 : build_int_cst (integer_type_node, ix < level), dims);
3259 : :
3260 : 1102 : return dims;
3261 : : }
3262 : :
3263 : : /* Retrieve the oacc function attrib and return it. Non-oacc
3264 : : functions will return NULL. */
3265 : :
3266 : : tree
3267 : 302310 : oacc_get_fn_attrib (tree fn)
3268 : : {
3269 : 302310 : return lookup_attribute (OACC_FN_ATTRIB, DECL_ATTRIBUTES (fn));
3270 : : }
3271 : :
3272 : : /* Return true if FN is an OpenMP or OpenACC offloading function. */
3273 : :
3274 : : bool
3275 : 588 : offloading_function_p (tree fn)
3276 : : {
3277 : 588 : tree attrs = DECL_ATTRIBUTES (fn);
3278 : 588 : return (lookup_attribute ("omp declare target", attrs)
3279 : 588 : || lookup_attribute ("omp target entrypoint", attrs));
3280 : : }
3281 : :
3282 : : /* Extract an oacc execution dimension from FN. FN must be an
3283 : : offloaded function or routine that has already had its execution
3284 : : dimensions lowered to the target-specific values. */
3285 : :
3286 : : int
3287 : 57156 : oacc_get_fn_dim_size (tree fn, int axis)
3288 : : {
3289 : 57156 : tree attrs = oacc_get_fn_attrib (fn);
3290 : :
3291 : 57156 : gcc_assert (axis < GOMP_DIM_MAX);
3292 : :
3293 : 57156 : tree dims = TREE_VALUE (attrs);
3294 : 115903 : while (axis--)
3295 : 58747 : dims = TREE_CHAIN (dims);
3296 : :
3297 : 57156 : int size = TREE_INT_CST_LOW (TREE_VALUE (dims));
3298 : :
3299 : 57156 : return size;
3300 : : }
3301 : :
3302 : : /* Extract the dimension axis from an IFN_GOACC_DIM_POS or
3303 : : IFN_GOACC_DIM_SIZE call. */
3304 : :
3305 : : int
3306 : 84701 : oacc_get_ifn_dim_arg (const gimple *stmt)
3307 : : {
3308 : 84701 : gcc_checking_assert (gimple_call_internal_fn (stmt) == IFN_GOACC_DIM_SIZE
3309 : : || gimple_call_internal_fn (stmt) == IFN_GOACC_DIM_POS);
3310 : 84701 : tree arg = gimple_call_arg (stmt, 0);
3311 : 84701 : HOST_WIDE_INT axis = TREE_INT_CST_LOW (arg);
3312 : :
3313 : 84701 : gcc_checking_assert (axis >= 0 && axis < GOMP_DIM_MAX);
3314 : 84701 : return (int) axis;
3315 : : }
3316 : :
3317 : : /* Build COMPONENT_REF and set TREE_THIS_VOLATILE and TREE_READONLY on it
3318 : : as appropriate. */
3319 : :
3320 : : tree
3321 : 283257 : omp_build_component_ref (tree obj, tree field)
3322 : : {
3323 : 283257 : tree ret = build3 (COMPONENT_REF, TREE_TYPE (field), obj, field, NULL);
3324 : 283257 : if (TREE_THIS_VOLATILE (field))
3325 : 62 : TREE_THIS_VOLATILE (ret) |= 1;
3326 : 283257 : if (TREE_READONLY (field))
3327 : 0 : TREE_READONLY (ret) |= 1;
3328 : 283257 : return ret;
3329 : : }
3330 : :
3331 : : /* Return true if NAME is the name of an omp_* runtime API call. */
3332 : : bool
3333 : 7223 : omp_runtime_api_procname (const char *name)
3334 : : {
3335 : 7223 : if (!startswith (name, "omp_"))
3336 : : return false;
3337 : :
3338 : : static const char *omp_runtime_apis[] =
3339 : : {
3340 : : /* This array has 3 sections. First omp_* calls that don't
3341 : : have any suffixes. */
3342 : : "aligned_alloc",
3343 : : "aligned_calloc",
3344 : : "alloc",
3345 : : "calloc",
3346 : : "free",
3347 : : "get_interop_int",
3348 : : "get_interop_ptr",
3349 : : "get_mapped_ptr",
3350 : : "get_num_interop_properties",
3351 : : "realloc",
3352 : : "target_alloc",
3353 : : "target_associate_ptr",
3354 : : "target_disassociate_ptr",
3355 : : "target_free",
3356 : : "target_is_accessible",
3357 : : "target_is_present",
3358 : : "target_memcpy",
3359 : : "target_memcpy_async",
3360 : : "target_memcpy_rect",
3361 : : "target_memcpy_rect_async",
3362 : : NULL,
3363 : : /* Now omp_* calls that are available as omp_* and omp_*_; however, the
3364 : : DECL_NAME is always omp_* without tailing underscore. */
3365 : : "capture_affinity",
3366 : : "destroy_allocator",
3367 : : "destroy_lock",
3368 : : "destroy_nest_lock",
3369 : : "display_affinity",
3370 : : "fulfill_event",
3371 : : "get_active_level",
3372 : : "get_affinity_format",
3373 : : "get_cancellation",
3374 : : "get_default_allocator",
3375 : : "get_default_device",
3376 : : "get_device_from_uid",
3377 : : "get_device_num",
3378 : : "get_dynamic",
3379 : : "get_initial_device",
3380 : : "get_interop_name",
3381 : : "get_interop_rc_desc",
3382 : : "get_interop_str",
3383 : : "get_interop_type_desc",
3384 : : "get_level",
3385 : : "get_max_active_levels",
3386 : : "get_max_task_priority",
3387 : : "get_max_teams",
3388 : : "get_max_threads",
3389 : : "get_nested",
3390 : : "get_num_devices",
3391 : : "get_num_places",
3392 : : "get_num_procs",
3393 : : "get_num_teams",
3394 : : "get_num_threads",
3395 : : "get_partition_num_places",
3396 : : "get_place_num",
3397 : : "get_proc_bind",
3398 : : "get_supported_active_levels",
3399 : : "get_team_num",
3400 : : "get_teams_thread_limit",
3401 : : "get_thread_limit",
3402 : : "get_thread_num",
3403 : : "get_wtick",
3404 : : "get_wtime",
3405 : : "in_explicit_task",
3406 : : "in_final",
3407 : : "in_parallel",
3408 : : "init_lock",
3409 : : "init_nest_lock",
3410 : : "is_initial_device",
3411 : : "pause_resource",
3412 : : "pause_resource_all",
3413 : : "set_affinity_format",
3414 : : "set_default_allocator",
3415 : : "set_lock",
3416 : : "set_nest_lock",
3417 : : "test_lock",
3418 : : "test_nest_lock",
3419 : : "unset_lock",
3420 : : "unset_nest_lock",
3421 : : NULL,
3422 : : /* And finally calls available as omp_*, omp_*_ and omp_*_8_; however,
3423 : : as DECL_NAME only omp_* and omp_*_8 appear. */
3424 : : "display_env",
3425 : : "get_ancestor_thread_num",
3426 : : "get_uid_from_device",
3427 : : "get_partition_place_nums",
3428 : : "get_place_num_procs",
3429 : : "get_place_proc_ids",
3430 : : "get_schedule",
3431 : : "get_team_size",
3432 : : "init_allocator",
3433 : : "set_default_device",
3434 : : "set_dynamic",
3435 : : "set_max_active_levels",
3436 : : "set_nested",
3437 : : "set_num_teams",
3438 : : "set_num_threads",
3439 : : "set_schedule",
3440 : : "set_teams_thread_limit"
3441 : : };
3442 : :
3443 : : int mode = 0;
3444 : 41167 : for (unsigned i = 0; i < ARRAY_SIZE (omp_runtime_apis); i++)
3445 : : {
3446 : 41166 : if (omp_runtime_apis[i] == NULL)
3447 : : {
3448 : 805 : mode++;
3449 : 805 : continue;
3450 : : }
3451 : 40361 : size_t len = strlen (omp_runtime_apis[i]);
3452 : 40361 : if (strncmp (name + 4, omp_runtime_apis[i], len) == 0
3453 : 917 : && (name[4 + len] == '\0'
3454 : 3 : || (mode > 1 && strcmp (name + 4 + len, "_8") == 0)))
3455 : : return true;
3456 : : }
3457 : : return false;
3458 : : }
3459 : :
3460 : : /* Return true if FNDECL is an omp_* runtime API call. */
3461 : :
3462 : : bool
3463 : 7380 : omp_runtime_api_call (const_tree fndecl)
3464 : : {
3465 : 7380 : tree declname = DECL_NAME (fndecl);
3466 : 7380 : if (!declname
3467 : 7380 : || (DECL_CONTEXT (fndecl) != NULL_TREE
3468 : 5368 : && TREE_CODE (DECL_CONTEXT (fndecl)) != TRANSLATION_UNIT_DECL)
3469 : 14184 : || !TREE_PUBLIC (fndecl))
3470 : : return false;
3471 : 6745 : return omp_runtime_api_procname (IDENTIFIER_POINTER (declname));
3472 : : }
3473 : :
3474 : : /* See "Additional Definitions for the OpenMP API Specification" document;
3475 : : associated IDs are 1, 2, ... */
3476 : : static const char* omp_interop_fr_str[] = {"cuda", "cuda_driver", "opencl",
3477 : : "sycl", "hip", "level_zero", "hsa"};
3478 : :
3479 : : /* Returns the foreign-runtime ID if found or 0 otherwise. */
3480 : :
3481 : : int
3482 : 28 : omp_get_fr_id_from_name (const char *str)
3483 : : {
3484 : 28 : static_assert (GOMP_INTEROP_IFR_LAST == ARRAY_SIZE (omp_interop_fr_str), "");
3485 : :
3486 : 107 : for (unsigned i = 0; i < ARRAY_SIZE (omp_interop_fr_str); ++i)
3487 : 105 : if (!strcmp (str, omp_interop_fr_str[i]))
3488 : 26 : return i + 1;
3489 : : return 0;
3490 : : }
3491 : :
3492 : : /* Returns the string value to a foreign-runtime integer value or NULL if value
3493 : : is not known. */
3494 : :
3495 : : const char *
3496 : 0 : omp_get_name_from_fr_id (int fr_id)
3497 : : {
3498 : 0 : if (fr_id < 1 || fr_id > (int) ARRAY_SIZE (omp_interop_fr_str))
3499 : : return NULL;
3500 : 0 : return omp_interop_fr_str[fr_id-1];
3501 : : }
3502 : :
3503 : : namespace omp_addr_tokenizer {
3504 : :
3505 : : /* We scan an expression by recursive descent, and build a vector of
3506 : : "omp_addr_token *" pointers representing a "parsed" version of the
3507 : : expression. The grammar we use is something like this:
3508 : :
3509 : : expr0::
3510 : : expr [section-access]
3511 : :
3512 : : expr::
3513 : : structured-expr access-method
3514 : : | array-base access-method
3515 : :
3516 : : structured-expr::
3517 : : structure-base component-selector
3518 : :
3519 : : arbitrary-expr::
3520 : : (anything else)
3521 : :
3522 : : structure-base::
3523 : : DECL access-method
3524 : : | structured-expr access-method
3525 : : | arbitrary-expr access-method
3526 : :
3527 : : array-base::
3528 : : DECL
3529 : : | arbitrary-expr
3530 : :
3531 : : access-method::
3532 : : DIRECT
3533 : : | REF
3534 : : | POINTER
3535 : : | REF_TO_POINTER
3536 : : | POINTER_OFFSET
3537 : : | REF_TO_POINTER_OFFSET
3538 : : | INDEXED_ARRAY
3539 : : | INDEXED_REF_TO_ARRAY
3540 : : | index-expr
3541 : :
3542 : : index-expr::
3543 : : INDEX_EXPR access-method
3544 : :
3545 : : component-selector::
3546 : : component-selector COMPONENT_REF
3547 : : | component-selector ARRAY_REF
3548 : : | COMPONENT_REF
3549 : :
3550 : : This tokenized form is then used both in parsing, for OpenMP clause
3551 : : expansion (for C and C++) and in gimplify.cc for sibling-list handling
3552 : : (for C, C++ and Fortran). */
3553 : :
3554 : 27970 : omp_addr_token::omp_addr_token (token_type t, tree e)
3555 : 27970 : : type(t), expr(e)
3556 : : {
3557 : 27970 : }
3558 : :
3559 : 111934 : omp_addr_token::omp_addr_token (access_method_kinds k, tree e)
3560 : 111934 : : type(ACCESS_METHOD), expr(e)
3561 : : {
3562 : 111934 : u.access_kind = k;
3563 : 111934 : }
3564 : :
3565 : 86268 : omp_addr_token::omp_addr_token (token_type t, structure_base_kinds k, tree e)
3566 : 86268 : : type(t), expr(e)
3567 : : {
3568 : 86268 : u.structure_base_kind = k;
3569 : 86268 : }
3570 : :
3571 : : static bool
3572 : 86271 : omp_parse_component_selector (tree *expr0)
3573 : : {
3574 : 86271 : tree expr = *expr0;
3575 : 86271 : tree last_component = NULL_TREE;
3576 : :
3577 : 86271 : while (TREE_CODE (expr) == COMPONENT_REF
3578 : 121183 : || TREE_CODE (expr) == ARRAY_REF)
3579 : : {
3580 : 34912 : if (TREE_CODE (expr) == COMPONENT_REF)
3581 : 33147 : last_component = expr;
3582 : :
3583 : 34912 : expr = TREE_OPERAND (expr, 0);
3584 : :
3585 : 34912 : if (TREE_CODE (TREE_TYPE (expr)) == REFERENCE_TYPE)
3586 : : break;
3587 : : }
3588 : :
3589 : 86271 : if (!last_component)
3590 : : return false;
3591 : :
3592 : 27970 : *expr0 = last_component;
3593 : 27970 : return true;
3594 : : }
3595 : :
3596 : : /* This handles references that have had convert_from_reference called on
3597 : : them, and also those that haven't. */
3598 : :
3599 : : static bool
3600 : 145408 : omp_parse_ref (tree *expr0)
3601 : : {
3602 : 145408 : tree expr = *expr0;
3603 : :
3604 : 145408 : if (TREE_CODE (TREE_TYPE (expr)) == REFERENCE_TYPE)
3605 : : return true;
3606 : 141433 : else if ((TREE_CODE (expr) == INDIRECT_REF
3607 : 103752 : || (TREE_CODE (expr) == MEM_REF
3608 : 0 : && integer_zerop (TREE_OPERAND (expr, 1))))
3609 : 141433 : && TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == REFERENCE_TYPE)
3610 : : {
3611 : 9313 : *expr0 = TREE_OPERAND (expr, 0);
3612 : 9313 : return true;
3613 : : }
3614 : :
3615 : : return false;
3616 : : }
3617 : :
3618 : : static bool
3619 : 102457 : omp_parse_pointer (tree *expr0, bool *has_offset)
3620 : : {
3621 : 102457 : tree expr = *expr0;
3622 : :
3623 : 102457 : *has_offset = false;
3624 : :
3625 : 102457 : if ((TREE_CODE (expr) == INDIRECT_REF
3626 : 75186 : || (TREE_CODE (expr) == MEM_REF
3627 : 0 : && integer_zerop (TREE_OPERAND (expr, 1))))
3628 : 102457 : && TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == POINTER_TYPE)
3629 : : {
3630 : 27271 : expr = TREE_OPERAND (expr, 0);
3631 : :
3632 : : /* The Fortran FE sometimes emits a no-op cast here. */
3633 : 27271 : STRIP_NOPS (expr);
3634 : :
3635 : 30189 : while (1)
3636 : : {
3637 : 30189 : if (TREE_CODE (expr) == COMPOUND_EXPR)
3638 : : {
3639 : 101 : expr = TREE_OPERAND (expr, 1);
3640 : 101 : STRIP_NOPS (expr);
3641 : : }
3642 : 30088 : else if (TREE_CODE (expr) == SAVE_EXPR)
3643 : 89 : expr = TREE_OPERAND (expr, 0);
3644 : 29999 : else if (TREE_CODE (expr) == POINTER_PLUS_EXPR)
3645 : : {
3646 : 2728 : *has_offset = true;
3647 : 2728 : expr = TREE_OPERAND (expr, 0);
3648 : : }
3649 : : else
3650 : : break;
3651 : : }
3652 : :
3653 : 27271 : STRIP_NOPS (expr);
3654 : :
3655 : 27271 : *expr0 = expr;
3656 : 27271 : return true;
3657 : : }
3658 : :
3659 : : return false;
3660 : : }
3661 : :
3662 : : static bool
3663 : 111934 : omp_parse_access_method (tree *expr0, enum access_method_kinds *kind)
3664 : : {
3665 : 111934 : tree expr = *expr0;
3666 : 111934 : bool has_offset;
3667 : :
3668 : 111934 : if (omp_parse_ref (&expr))
3669 : 9477 : *kind = ACCESS_REF;
3670 : 102457 : else if (omp_parse_pointer (&expr, &has_offset))
3671 : : {
3672 : 27271 : if (omp_parse_ref (&expr))
3673 : 5574 : *kind = has_offset ? ACCESS_REF_TO_POINTER_OFFSET
3674 : : : ACCESS_REF_TO_POINTER;
3675 : : else
3676 : 46240 : *kind = has_offset ? ACCESS_POINTER_OFFSET : ACCESS_POINTER;
3677 : : }
3678 : 75186 : else if (TREE_CODE (expr) == ARRAY_REF)
3679 : : {
3680 : 12690 : while (TREE_CODE (expr) == ARRAY_REF)
3681 : 6487 : expr = TREE_OPERAND (expr, 0);
3682 : 6203 : if (omp_parse_ref (&expr))
3683 : 640 : *kind = ACCESS_INDEXED_REF_TO_ARRAY;
3684 : : else
3685 : 5563 : *kind = ACCESS_INDEXED_ARRAY;
3686 : : }
3687 : : else
3688 : 68983 : *kind = ACCESS_DIRECT;
3689 : :
3690 : 111934 : STRIP_NOPS (expr);
3691 : :
3692 : 111934 : *expr0 = expr;
3693 : 111934 : return true;
3694 : : }
3695 : :
3696 : : static bool
3697 : 111934 : omp_parse_access_methods (vec<omp_addr_token *> &addr_tokens, tree *expr0)
3698 : : {
3699 : 111934 : tree expr = *expr0;
3700 : 111934 : enum access_method_kinds kind;
3701 : 111934 : tree am_expr;
3702 : :
3703 : 111934 : if (omp_parse_access_method (&expr, &kind))
3704 : 111934 : am_expr = expr;
3705 : :
3706 : 111934 : if (TREE_CODE (expr) == INDIRECT_REF
3707 : 111934 : || TREE_CODE (expr) == MEM_REF
3708 : 110837 : || TREE_CODE (expr) == ARRAY_REF)
3709 : 1488 : omp_parse_access_methods (addr_tokens, &expr);
3710 : :
3711 : 111934 : addr_tokens.safe_push (new omp_addr_token (kind, am_expr));
3712 : :
3713 : 111934 : *expr0 = expr;
3714 : 111934 : return true;
3715 : : }
3716 : :
3717 : : static bool omp_parse_structured_expr (vec<omp_addr_token *> &, tree *);
3718 : :
3719 : : static bool
3720 : 86268 : omp_parse_structure_base (vec<omp_addr_token *> &addr_tokens,
3721 : : tree *expr0, structure_base_kinds *kind,
3722 : : vec<omp_addr_token *> &base_access_tokens,
3723 : : bool allow_structured = true)
3724 : : {
3725 : 86268 : tree expr = *expr0;
3726 : :
3727 : 86268 : if (allow_structured)
3728 : 27970 : omp_parse_access_methods (base_access_tokens, &expr);
3729 : :
3730 : 86268 : if (DECL_P (expr))
3731 : : {
3732 : 81953 : *kind = BASE_DECL;
3733 : 81953 : return true;
3734 : : }
3735 : :
3736 : 4315 : if (allow_structured && omp_parse_structured_expr (addr_tokens, &expr))
3737 : : {
3738 : 3792 : *kind = BASE_COMPONENT_EXPR;
3739 : 3792 : *expr0 = expr;
3740 : 3792 : return true;
3741 : : }
3742 : :
3743 : 523 : *kind = BASE_ARBITRARY_EXPR;
3744 : 523 : *expr0 = expr;
3745 : 523 : return true;
3746 : : }
3747 : :
3748 : : static bool
3749 : 86271 : omp_parse_structured_expr (vec<omp_addr_token *> &addr_tokens, tree *expr0)
3750 : : {
3751 : 86271 : tree expr = *expr0;
3752 : 86271 : tree base_component = NULL_TREE;
3753 : 86271 : structure_base_kinds struct_base_kind;
3754 : 86271 : auto_vec<omp_addr_token *> base_access_tokens;
3755 : :
3756 : 86271 : if (omp_parse_component_selector (&expr))
3757 : 27970 : base_component = expr;
3758 : : else
3759 : : return false;
3760 : :
3761 : 27970 : gcc_assert (TREE_CODE (expr) == COMPONENT_REF);
3762 : 27970 : expr = TREE_OPERAND (expr, 0);
3763 : :
3764 : 27970 : tree structure_base = expr;
3765 : :
3766 : 27970 : if (!omp_parse_structure_base (addr_tokens, &expr, &struct_base_kind,
3767 : : base_access_tokens))
3768 : : return false;
3769 : :
3770 : 27970 : addr_tokens.safe_push (new omp_addr_token (STRUCTURE_BASE, struct_base_kind,
3771 : 27970 : structure_base));
3772 : 27970 : addr_tokens.safe_splice (base_access_tokens);
3773 : 27970 : addr_tokens.safe_push (new omp_addr_token (COMPONENT_SELECTOR,
3774 : 27970 : base_component));
3775 : :
3776 : 27970 : *expr0 = expr;
3777 : :
3778 : 27970 : return true;
3779 : 86271 : }
3780 : :
3781 : : static bool
3782 : 58298 : omp_parse_array_expr (vec<omp_addr_token *> &addr_tokens, tree *expr0)
3783 : : {
3784 : 58298 : tree expr = *expr0;
3785 : 58298 : structure_base_kinds s_kind;
3786 : 58298 : auto_vec<omp_addr_token *> base_access_tokens;
3787 : :
3788 : 58298 : if (!omp_parse_structure_base (addr_tokens, &expr, &s_kind,
3789 : : base_access_tokens, false))
3790 : : return false;
3791 : :
3792 : 58298 : addr_tokens.safe_push (new omp_addr_token (ARRAY_BASE, s_kind, expr));
3793 : 58298 : addr_tokens.safe_splice (base_access_tokens);
3794 : :
3795 : 58298 : *expr0 = expr;
3796 : 58298 : return true;
3797 : 58298 : }
3798 : :
3799 : : /* Return TRUE if the ACCESS_METHOD token at index 'i' has a further
3800 : : ACCESS_METHOD chained after it (e.g., if we're processing an expression
3801 : : containing multiple pointer indirections). */
3802 : :
3803 : : bool
3804 : 44217 : omp_access_chain_p (vec<omp_addr_token *> &addr_tokens, unsigned i)
3805 : : {
3806 : 44217 : gcc_assert (addr_tokens[i]->type == ACCESS_METHOD);
3807 : 44217 : return (i + 1 < addr_tokens.length ()
3808 : 44217 : && addr_tokens[i + 1]->type == ACCESS_METHOD);
3809 : : }
3810 : :
3811 : : /* Return the address of the object accessed by the ACCESS_METHOD token
3812 : : at 'i': either of the next access method's expr, or of EXPR if we're at
3813 : : the end of the list of tokens. */
3814 : :
3815 : : tree
3816 : 4178 : omp_accessed_addr (vec<omp_addr_token *> &addr_tokens, unsigned i, tree expr)
3817 : : {
3818 : 8356 : if (i + 1 < addr_tokens.length ())
3819 : 26 : return build_fold_addr_expr (addr_tokens[i + 1]->expr);
3820 : : else
3821 : 4152 : return build_fold_addr_expr (expr);
3822 : : }
3823 : :
3824 : : } /* namespace omp_addr_tokenizer. */
3825 : :
3826 : : bool
3827 : 82476 : omp_parse_expr (vec<omp_addr_token *> &addr_tokens, tree expr)
3828 : : {
3829 : 82476 : using namespace omp_addr_tokenizer;
3830 : 82476 : auto_vec<omp_addr_token *> expr_access_tokens;
3831 : :
3832 : 82476 : if (!omp_parse_access_methods (expr_access_tokens, &expr))
3833 : : return false;
3834 : :
3835 : 82476 : if (omp_parse_structured_expr (addr_tokens, &expr))
3836 : : ;
3837 : 58298 : else if (omp_parse_array_expr (addr_tokens, &expr))
3838 : : ;
3839 : : else
3840 : : return false;
3841 : :
3842 : 82476 : addr_tokens.safe_splice (expr_access_tokens);
3843 : :
3844 : 82476 : return true;
3845 : 82476 : }
3846 : :
3847 : : DEBUG_FUNCTION void
3848 : 0 : debug_omp_tokenized_addr (vec<omp_addr_token *> &addr_tokens,
3849 : : bool with_exprs)
3850 : : {
3851 : 0 : using namespace omp_addr_tokenizer;
3852 : 0 : const char *sep = with_exprs ? " " : "";
3853 : :
3854 : 0 : for (auto e : addr_tokens)
3855 : : {
3856 : 0 : const char *pfx = "";
3857 : :
3858 : 0 : fputs (sep, stderr);
3859 : :
3860 : 0 : switch (e->type)
3861 : : {
3862 : 0 : case COMPONENT_SELECTOR:
3863 : 0 : fputs ("component_selector", stderr);
3864 : 0 : break;
3865 : 0 : case ACCESS_METHOD:
3866 : 0 : switch (e->u.access_kind)
3867 : : {
3868 : 0 : case ACCESS_DIRECT:
3869 : 0 : fputs ("access_direct", stderr);
3870 : 0 : break;
3871 : 0 : case ACCESS_REF:
3872 : 0 : fputs ("access_ref", stderr);
3873 : 0 : break;
3874 : 0 : case ACCESS_POINTER:
3875 : 0 : fputs ("access_pointer", stderr);
3876 : 0 : break;
3877 : 0 : case ACCESS_POINTER_OFFSET:
3878 : 0 : fputs ("access_pointer_offset", stderr);
3879 : 0 : break;
3880 : 0 : case ACCESS_REF_TO_POINTER:
3881 : 0 : fputs ("access_ref_to_pointer", stderr);
3882 : 0 : break;
3883 : 0 : case ACCESS_REF_TO_POINTER_OFFSET:
3884 : 0 : fputs ("access_ref_to_pointer_offset", stderr);
3885 : 0 : break;
3886 : 0 : case ACCESS_INDEXED_ARRAY:
3887 : 0 : fputs ("access_indexed_array", stderr);
3888 : 0 : break;
3889 : 0 : case ACCESS_INDEXED_REF_TO_ARRAY:
3890 : 0 : fputs ("access_indexed_ref_to_array", stderr);
3891 : 0 : break;
3892 : : }
3893 : : break;
3894 : 0 : case ARRAY_BASE:
3895 : 0 : case STRUCTURE_BASE:
3896 : 0 : pfx = e->type == ARRAY_BASE ? "array_" : "struct_";
3897 : 0 : switch (e->u.structure_base_kind)
3898 : : {
3899 : 0 : case BASE_DECL:
3900 : 0 : fprintf (stderr, "%sbase_decl", pfx);
3901 : 0 : break;
3902 : 0 : case BASE_COMPONENT_EXPR:
3903 : 0 : fputs ("base_component_expr", stderr);
3904 : 0 : break;
3905 : 0 : case BASE_ARBITRARY_EXPR:
3906 : 0 : fprintf (stderr, "%sbase_arbitrary_expr", pfx);
3907 : 0 : break;
3908 : : }
3909 : : break;
3910 : : }
3911 : 0 : if (with_exprs)
3912 : : {
3913 : 0 : fputs (" [", stderr);
3914 : 0 : print_generic_expr (stderr, e->expr);
3915 : 0 : fputc (']', stderr);
3916 : 0 : sep = ",\n ";
3917 : : }
3918 : : else
3919 : : sep = " ";
3920 : : }
3921 : :
3922 : 0 : fputs ("\n", stderr);
3923 : 0 : }
3924 : :
3925 : : /* Return number of iterations of loop I in FOR_STMT. If PSTEP is non-NULL,
3926 : : *PSTEP will be the loop step. */
3927 : :
3928 : : tree
3929 : 2647 : omp_loop_number_of_iterations (tree for_stmt, int i, tree *pstep)
3930 : : {
3931 : 2647 : tree t = TREE_VEC_ELT (OMP_FOR_INIT (for_stmt), i);
3932 : 2647 : gcc_assert (TREE_CODE (t) == MODIFY_EXPR);
3933 : 2647 : tree decl = TREE_OPERAND (t, 0);
3934 : 2647 : tree n1 = TREE_OPERAND (t, 1);
3935 : 2647 : tree type = TREE_TYPE (decl);
3936 : 2647 : tree cond = TREE_VEC_ELT (OMP_FOR_COND (for_stmt), i);
3937 : 2647 : gcc_assert (COMPARISON_CLASS_P (cond));
3938 : 2647 : gcc_assert (TREE_OPERAND (cond, 0) == decl);
3939 : 2647 : tree_code cond_code = TREE_CODE (cond);
3940 : 2647 : tree n2 = TREE_OPERAND (cond, 1);
3941 : 2647 : t = TREE_VEC_ELT (OMP_FOR_INCR (for_stmt), i);
3942 : 2647 : tree step = NULL_TREE;
3943 : 2647 : switch (TREE_CODE (t))
3944 : : {
3945 : 1141 : case PREINCREMENT_EXPR:
3946 : 1141 : case POSTINCREMENT_EXPR:
3947 : 1141 : gcc_assert (!POINTER_TYPE_P (type));
3948 : 1141 : gcc_assert (TREE_OPERAND (t, 0) == decl);
3949 : 1141 : step = build_int_cst (type, 1);
3950 : 1141 : break;
3951 : 42 : case PREDECREMENT_EXPR:
3952 : 42 : case POSTDECREMENT_EXPR:
3953 : 42 : gcc_assert (!POINTER_TYPE_P (type));
3954 : 42 : gcc_assert (TREE_OPERAND (t, 0) == decl);
3955 : 42 : step = build_int_cst (type, -1);
3956 : 42 : break;
3957 : 1464 : case MODIFY_EXPR:
3958 : 1464 : gcc_assert (TREE_OPERAND (t, 0) == decl);
3959 : 1464 : t = TREE_OPERAND (t, 1);
3960 : 1464 : switch (TREE_CODE (t))
3961 : : {
3962 : 1389 : case PLUS_EXPR:
3963 : 1389 : if (TREE_OPERAND (t, 1) == decl)
3964 : : {
3965 : 3 : TREE_OPERAND (t, 1) = TREE_OPERAND (t, 0);
3966 : 3 : TREE_OPERAND (t, 0) = decl;
3967 : : }
3968 : : /* FALLTHRU */
3969 : : case POINTER_PLUS_EXPR:
3970 : : case MINUS_EXPR:
3971 : 1464 : step = omp_get_for_step_from_incr (EXPR_LOCATION (t), t);
3972 : 1464 : break;
3973 : 0 : default:
3974 : 0 : gcc_unreachable ();
3975 : : }
3976 : 1464 : break;
3977 : 0 : default:
3978 : 0 : gcc_unreachable ();
3979 : : }
3980 : 2647 : omp_adjust_for_condition (EXPR_LOCATION (for_stmt), &cond_code, &n2,
3981 : : decl, step);
3982 : 2647 : if (pstep)
3983 : 2099 : *pstep = step;
3984 : 2647 : if (INTEGRAL_TYPE_P (type)
3985 : 2647 : && TYPE_PRECISION (type) < TYPE_PRECISION (long_long_integer_type_node))
3986 : : {
3987 : 2538 : n1 = fold_convert (long_long_integer_type_node, n1);
3988 : 2538 : n2 = fold_convert (long_long_integer_type_node, n2);
3989 : 2538 : step = fold_convert (long_long_integer_type_node, step);
3990 : : }
3991 : 2647 : if (cond_code == LT_EXPR
3992 : 156 : || POINTER_TYPE_P (type)
3993 : 2783 : || !TYPE_UNSIGNED (TREE_TYPE (n1)))
3994 : : {
3995 : 2647 : if (POINTER_TYPE_P (type))
3996 : 60 : t = fold_build2 (POINTER_DIFF_EXPR, ssizetype, n2, n1);
3997 : : else
3998 : 2587 : t = fold_build2 (MINUS_EXPR, TREE_TYPE (n1), n2, n1);
3999 : 2647 : t = fold_build2 (CEIL_DIV_EXPR, TREE_TYPE (t), t, step);
4000 : : }
4001 : : else
4002 : : {
4003 : 0 : t = fold_build2 (MINUS_EXPR, type, n1, n2);
4004 : 0 : t = fold_build2 (CEIL_DIV_EXPR, type, t,
4005 : : fold_build1 (NEGATE_EXPR, type, step));
4006 : : }
4007 : 2647 : return t;
4008 : : }
4009 : :
4010 : : /* Tile transformation:
4011 : : Original loop:
4012 : :
4013 : : #pragma omp tile sizes(16, 32)
4014 : : for (i = 0; i < k; ++i)
4015 : : for (j = 0; j < 128; j += 2)
4016 : : {
4017 : : baz (i, j);
4018 : : }
4019 : :
4020 : : Transformed loop:
4021 : : #pragma omp tile sizes(16, 32)
4022 : : for (i.0 = 0; i.0 < k; i.0 += 16)
4023 : : for (j.0 = 0; j.0 < 128; j.0 += 64)
4024 : : {
4025 : : i = i.0;
4026 : : i.1 = MIN_EXPR <i.0 + 16, k>;
4027 : : goto <D.2783>;
4028 : : <D.2782>:;
4029 : : j = j.0;
4030 : : j.1 = j.0 + 32;
4031 : : goto <D.2786>;
4032 : : <D.2785>:;
4033 : : {
4034 : : baz (i, j);
4035 : : }
4036 : : j += 2;
4037 : : <D.2786>:;
4038 : : if (j < j.1) goto <D.2785>; else goto <D.2787>;
4039 : : <D.2787>:;
4040 : : ++i;
4041 : : <D.2783>:;
4042 : : if (i < i.1) goto <D.2782>; else goto <D.2784>;
4043 : : <D.2784>:;
4044 : : }
4045 : :
4046 : : where the grid loops have canonical form, but the inner
4047 : : loops don't and so are immediately lowered. */
4048 : :
4049 : : static void
4050 : 1958 : omp_apply_tile (tree for_stmt, tree sizes, int size)
4051 : : {
4052 : 1958 : tree pre_body = NULL_TREE, post_body = NULL_TREE;
4053 : 1958 : tree orig_sizes = sizes;
4054 : 1958 : if (OMP_FOR_NON_RECTANGULAR (for_stmt))
4055 : : {
4056 : 51 : error_at (EXPR_LOCATION (for_stmt), "non-rectangular %<tile%>");
4057 : 51 : return;
4058 : : }
4059 : 4434 : for (int i = 0; i < TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt)); i++)
4060 : : {
4061 : 2527 : if (orig_sizes)
4062 : : {
4063 : 1734 : size = tree_to_uhwi (TREE_VALUE (sizes));
4064 : 1734 : sizes = TREE_CHAIN (sizes);
4065 : : }
4066 : 2527 : if (size == 1)
4067 : 428 : continue;
4068 : 2099 : if (OMP_FOR_ORIG_DECLS (for_stmt) == NULL_TREE)
4069 : : {
4070 : 522 : OMP_FOR_ORIG_DECLS (for_stmt)
4071 : 522 : = make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt)));
4072 : 1188 : for (int j = 0; j < TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt)); j++)
4073 : : {
4074 : 666 : gcc_assert (TREE_CODE (TREE_VEC_ELT (OMP_FOR_INIT (for_stmt), j))
4075 : : == MODIFY_EXPR);
4076 : 666 : TREE_VEC_ELT (OMP_FOR_ORIG_DECLS (for_stmt), j)
4077 : 1332 : = TREE_OPERAND (TREE_VEC_ELT (OMP_FOR_INIT (for_stmt), j), 0);
4078 : : }
4079 : : }
4080 : 2099 : tree step;
4081 : 2099 : tree iters = omp_loop_number_of_iterations (for_stmt, i, &step);
4082 : 2099 : tree t = TREE_VEC_ELT (OMP_FOR_INIT (for_stmt), i);
4083 : 2099 : tree decl = TREE_OPERAND (t, 0);
4084 : 2099 : tree type = TREE_TYPE (decl);
4085 : 2099 : tree griddecl = create_tmp_var_raw (type);
4086 : 2099 : DECL_CONTEXT (griddecl) = current_function_decl;
4087 : 2099 : t = build1 (DECL_EXPR, void_type_node, griddecl);
4088 : 2099 : append_to_statement_list (t, &OMP_FOR_PRE_BODY (for_stmt));
4089 : 2099 : TREE_OPERAND (TREE_VEC_ELT (OMP_FOR_INIT (for_stmt), i), 0) = griddecl;
4090 : 2099 : TREE_PRIVATE (TREE_VEC_ELT (OMP_FOR_INIT (for_stmt), i)) = 1;
4091 : 2099 : tree cond = TREE_VEC_ELT (OMP_FOR_COND (for_stmt), i);
4092 : 2099 : TREE_OPERAND (cond, 0) = griddecl;
4093 : 2099 : tree ub = save_expr (TREE_OPERAND (cond, 1));
4094 : 2099 : TREE_OPERAND (cond, 1) = ub;
4095 : 2099 : t = TREE_VEC_ELT (OMP_FOR_INCR (for_stmt), i);
4096 : 2099 : if (TREE_CODE (cond) == NE_EXPR)
4097 : : {
4098 : 163 : tree_code cond_code = TREE_CODE (cond);
4099 : 163 : omp_adjust_for_condition (EXPR_LOCATION (for_stmt), &cond_code,
4100 : : &ub, griddecl, step);
4101 : 163 : TREE_SET_CODE (cond, cond_code);
4102 : : }
4103 : 2099 : step = save_expr (step);
4104 : 2099 : tree gridstep = fold_build2 (MULT_EXPR, TREE_TYPE (step),
4105 : : step, build_int_cst (TREE_TYPE (step),
4106 : : size));
4107 : 2099 : if (POINTER_TYPE_P (type))
4108 : 52 : t = build2 (POINTER_PLUS_EXPR, type, griddecl,
4109 : : fold_convert (sizetype, gridstep));
4110 : : else
4111 : 2047 : t = build2 (PLUS_EXPR, type, griddecl, gridstep);
4112 : 2099 : t = build2 (MODIFY_EXPR, type, griddecl, t);
4113 : 2099 : TREE_VEC_ELT (OMP_FOR_INCR (for_stmt), i) = t;
4114 : 2099 : t = build2 (MODIFY_EXPR, type, decl, griddecl);
4115 : 2099 : append_to_statement_list (t, &pre_body);
4116 : 2099 : if (POINTER_TYPE_P (type))
4117 : 52 : t = build2 (POINTER_PLUS_EXPR, type, griddecl,
4118 : : fold_convert (sizetype, gridstep));
4119 : : else
4120 : 2047 : t = build2 (PLUS_EXPR, type, griddecl, gridstep);
4121 : 2099 : bool minmax_needed = true;
4122 : 2099 : if (TREE_CODE (iters) == INTEGER_CST)
4123 : : {
4124 : 1135 : wide_int witers = wi::to_wide (iters);
4125 : 1135 : wide_int wsize = wide_int::from (size, witers.get_precision (),
4126 : 1135 : TYPE_SIGN (TREE_TYPE (iters)));
4127 : 1135 : if (wi::multiple_of_p (witers, wsize, TYPE_SIGN (TREE_TYPE (iters))))
4128 : 417 : minmax_needed = false;
4129 : 1135 : }
4130 : 1135 : if (minmax_needed)
4131 : 1682 : switch (TREE_CODE (cond))
4132 : : {
4133 : 251 : case LE_EXPR:
4134 : 251 : if (POINTER_TYPE_P (type))
4135 : 4 : t = build2 (MIN_EXPR, type, t,
4136 : 4 : build2 (POINTER_PLUS_EXPR, type, ub, size_int (1)));
4137 : : else
4138 : 247 : t = build2 (MIN_EXPR, type, t,
4139 : : build2 (PLUS_EXPR, type, ub, build_one_cst (type)));
4140 : : break;
4141 : 1375 : case LT_EXPR:
4142 : 1375 : t = build2 (MIN_EXPR, type, t, ub);
4143 : 1375 : break;
4144 : 28 : case GE_EXPR:
4145 : 28 : if (POINTER_TYPE_P (type))
4146 : 8 : t = build2 (MAX_EXPR, type, t,
4147 : 8 : build2 (POINTER_PLUS_EXPR, type, ub, size_int (-1)));
4148 : : else
4149 : 20 : t = build2 (MAX_EXPR, type, t,
4150 : : build2 (PLUS_EXPR, type, ub,
4151 : : build_minus_one_cst (type)));
4152 : : break;
4153 : 28 : case GT_EXPR:
4154 : 28 : t = build2 (MAX_EXPR, type, t, ub);
4155 : 28 : break;
4156 : 0 : default:
4157 : 0 : gcc_unreachable ();
4158 : : }
4159 : 2099 : tree end = create_tmp_var_raw (type);
4160 : 2099 : DECL_CONTEXT (end) = current_function_decl;
4161 : 2099 : end = build4 (TARGET_EXPR, type, end, t, NULL_TREE, NULL_TREE);
4162 : 2099 : TREE_SIDE_EFFECTS (end) = 1;
4163 : 2099 : append_to_statement_list (end, &pre_body);
4164 : 2099 : tree lab1 = create_artificial_label (UNKNOWN_LOCATION);
4165 : 2099 : tree lab2 = create_artificial_label (UNKNOWN_LOCATION);
4166 : 2099 : t = build1 (GOTO_EXPR, void_type_node, lab2);
4167 : 2099 : append_to_statement_list (t, &pre_body);
4168 : 2099 : t = build1 (LABEL_EXPR, void_type_node, lab1);
4169 : 2099 : append_to_statement_list (t, &pre_body);
4170 : 2099 : tree this_post_body = NULL_TREE;
4171 : 2099 : if (POINTER_TYPE_P (type))
4172 : 52 : t = build2 (POINTER_PLUS_EXPR, type, decl,
4173 : : fold_convert (sizetype, step));
4174 : : else
4175 : 2047 : t = build2 (PLUS_EXPR, type, decl, step);
4176 : 2099 : t = build2 (MODIFY_EXPR, type, decl, t);
4177 : 2099 : append_to_statement_list (t, &this_post_body);
4178 : 2099 : t = build1 (LABEL_EXPR, void_type_node, lab2);
4179 : 2099 : append_to_statement_list (t, &this_post_body);
4180 : 2165 : t = build2 ((TREE_CODE (cond) == LT_EXPR || TREE_CODE (cond) == LE_EXPR)
4181 : : ? LT_EXPR : GT_EXPR, boolean_type_node, decl, end);
4182 : 2099 : if (orig_sizes == NULL_TREE)
4183 : : {
4184 : 745 : gcc_assert (i == 0);
4185 : 745 : t = build3 (ANNOTATE_EXPR, TREE_TYPE (t), t,
4186 : : build_int_cst (integer_type_node,
4187 : 745 : annot_expr_unroll_kind),
4188 : : build_int_cst (integer_type_node, size));
4189 : : }
4190 : 2099 : t = build3 (COND_EXPR, void_type_node, t,
4191 : : build1 (GOTO_EXPR, void_type_node, lab1), NULL_TREE);
4192 : 2099 : append_to_statement_list (t, &this_post_body);
4193 : 2099 : append_to_statement_list (post_body, &this_post_body);
4194 : 2099 : post_body = this_post_body;
4195 : : }
4196 : 1907 : if (pre_body || post_body)
4197 : : {
4198 : 1614 : append_to_statement_list (OMP_FOR_BODY (for_stmt), &pre_body);
4199 : 1614 : append_to_statement_list (post_body, &pre_body);
4200 : 1614 : OMP_FOR_BODY (for_stmt) = pre_body;
4201 : : }
4202 : : }
4203 : :
4204 : : /* Callback for walk_tree to find nested loop transforming construct. */
4205 : :
4206 : : static tree
4207 : 9261 : find_nested_loop_xform (tree *tp, int *walk_subtrees, void *data)
4208 : : {
4209 : 9261 : tree **pdata = (tree **) data;
4210 : 9261 : *walk_subtrees = 0;
4211 : 9261 : switch (TREE_CODE (*tp))
4212 : : {
4213 : 1987 : case OMP_TILE:
4214 : 1987 : case OMP_UNROLL:
4215 : 1987 : pdata[1] = tp;
4216 : 1987 : return *tp;
4217 : 2581 : case BIND_EXPR:
4218 : 2581 : if (BIND_EXPR_VARS (*tp)
4219 : 2581 : || (BIND_EXPR_BLOCK (*tp)
4220 : 1270 : && BLOCK_VARS (BIND_EXPR_BLOCK (*tp))))
4221 : 1311 : pdata[0] = tp;
4222 : 2581 : *walk_subtrees = 1;
4223 : 2581 : break;
4224 : 425 : case STATEMENT_LIST:
4225 : 425 : if (!tsi_one_before_end_p (tsi_start (*tp)))
4226 : 425 : pdata[0] = tp;
4227 : 425 : *walk_subtrees = 1;
4228 : 425 : break;
4229 : 36 : case TRY_FINALLY_EXPR:
4230 : 36 : case CLEANUP_POINT_EXPR:
4231 : 36 : pdata[0] = tp;
4232 : 36 : *walk_subtrees = 1;
4233 : 36 : break;
4234 : : default:
4235 : : break;
4236 : : }
4237 : : return NULL;
4238 : : }
4239 : :
4240 : : /* Main entry point for performing OpenMP loop transformations. */
4241 : :
4242 : : void
4243 : 58471 : omp_maybe_apply_loop_xforms (tree *expr_p, tree for_clauses)
4244 : : {
4245 : 58471 : tree for_stmt = *expr_p;
4246 : :
4247 : 58471 : switch (TREE_CODE (for_stmt))
4248 : : {
4249 : 3923 : case OMP_TILE:
4250 : 3923 : case OMP_UNROLL:
4251 : 3923 : if (OMP_LOOPXFORM_LOWERED (for_stmt))
4252 : : return;
4253 : : break;
4254 : : default:
4255 : : break;
4256 : : }
4257 : :
4258 : : tree *inner_expr_p = expr_p;
4259 : : tree inner_for_stmt = for_stmt;
4260 : 138690 : for (int i = 0; i < TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt)); i++)
4261 : : {
4262 : : /* If some loop nest needs one or more loops in canonical form
4263 : : from nested loop transforming constructs, first perform the
4264 : : loop transformation on the nested construct and then move over
4265 : : the corresponding loops in canonical form from the inner construct
4266 : : to the outer one. */
4267 : 81941 : if (TREE_VEC_ELT (OMP_FOR_INIT (for_stmt), i) == NULL_TREE)
4268 : : {
4269 : 1516 : if (inner_for_stmt == for_stmt
4270 : 3008 : && omp_find_clause (for_clauses ? for_clauses
4271 : 1492 : : OMP_FOR_CLAUSES (for_stmt),
4272 : : OMP_CLAUSE_ORDERED))
4273 : : {
4274 : 73 : error_at (EXPR_LOCATION (for_stmt),
4275 : : "%<ordered%> clause used with generated loops");
4276 : 73 : *expr_p = void_node;
4277 : 73 : return;
4278 : : }
4279 : 1443 : tree *data[2] = { NULL, NULL };
4280 : 1443 : walk_tree (&OMP_FOR_BODY (inner_for_stmt),
4281 : : find_nested_loop_xform, &data, NULL);
4282 : 1443 : gcc_assert (data[1]);
4283 : 1443 : if (data[0])
4284 : : {
4285 : : /* If there is a BIND_EXPR declaring some vars, or statement
4286 : : list with more than one stmt etc., move the intervening
4287 : : code around the outermost loop. */
4288 : 1008 : tree t = *inner_expr_p;
4289 : 1008 : *inner_expr_p = OMP_FOR_BODY (inner_for_stmt);
4290 : 1008 : OMP_FOR_BODY (inner_for_stmt) = *data[1];
4291 : 1008 : *data[1] = t;
4292 : 1008 : inner_expr_p = data[1];
4293 : 1008 : data[1] = &OMP_FOR_BODY (inner_for_stmt);
4294 : : }
4295 : 1443 : inner_for_stmt = *data[1];
4296 : :
4297 : 1443 : omp_maybe_apply_loop_xforms (data[1], NULL_TREE);
4298 : 1443 : if (*data[1] != inner_for_stmt)
4299 : : {
4300 : 544 : tree *data2[2] = { NULL, NULL };
4301 : 544 : walk_tree (data[1], find_nested_loop_xform, &data2, NULL);
4302 : 544 : gcc_assert (data2[1]
4303 : : && *data2[1] == inner_for_stmt
4304 : : && data2[0]);
4305 : 544 : tree t = *inner_expr_p;
4306 : 544 : *inner_expr_p = *data[1];
4307 : 544 : *data[1] = *data2[1];
4308 : 544 : *data2[1] = t;
4309 : 544 : inner_expr_p = data2[1];
4310 : : }
4311 : 1443 : tree clauses = OMP_FOR_CLAUSES (inner_for_stmt);
4312 : 1443 : gcc_checking_assert (TREE_CODE (inner_for_stmt) != OMP_UNROLL
4313 : : || omp_find_clause (clauses,
4314 : : OMP_CLAUSE_PARTIAL));
4315 : 1443 : append_to_statement_list (OMP_FOR_PRE_BODY (inner_for_stmt),
4316 : : &OMP_FOR_PRE_BODY (for_stmt));
4317 : 1443 : OMP_FOR_PRE_BODY (inner_for_stmt) = NULL_TREE;
4318 : 1443 : if (OMP_FOR_ORIG_DECLS (for_stmt) == NULL_TREE
4319 : 1443 : && OMP_FOR_ORIG_DECLS (inner_for_stmt) != NULL_TREE)
4320 : : {
4321 : 624 : OMP_FOR_ORIG_DECLS (for_stmt)
4322 : 624 : = make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt)));
4323 : 1466 : for (int j = 0; j < TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt));
4324 : : j++)
4325 : : {
4326 : 842 : if (TREE_VEC_ELT (OMP_FOR_INIT (for_stmt), j) == NULL_TREE)
4327 : 717 : continue;
4328 : 125 : gcc_assert (TREE_CODE (TREE_VEC_ELT (OMP_FOR_INIT (for_stmt),
4329 : : j)) == MODIFY_EXPR);
4330 : 125 : TREE_VEC_ELT (OMP_FOR_ORIG_DECLS (for_stmt), j)
4331 : 250 : = TREE_OPERAND (TREE_VEC_ELT (OMP_FOR_INIT (for_stmt), j),
4332 : : 0);
4333 : : }
4334 : : }
4335 : 3104 : for (int j = 0; j < TREE_VEC_LENGTH (OMP_FOR_INIT (inner_for_stmt));
4336 : : ++j)
4337 : : {
4338 : 1924 : if (i + j == TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt)))
4339 : : break;
4340 : 1661 : if (OMP_FOR_ORIG_DECLS (for_stmt))
4341 : : {
4342 : 1576 : if (OMP_FOR_ORIG_DECLS (inner_for_stmt))
4343 : : {
4344 : 1576 : TREE_VEC_ELT (OMP_FOR_ORIG_DECLS (for_stmt), i + j)
4345 : 1576 : = TREE_VEC_ELT (OMP_FOR_ORIG_DECLS (inner_for_stmt),
4346 : : j);
4347 : 1576 : TREE_VEC_ELT (OMP_FOR_ORIG_DECLS (inner_for_stmt), j)
4348 : 1576 : = NULL_TREE;
4349 : : }
4350 : : else
4351 : : {
4352 : 0 : tree t = TREE_VEC_ELT (OMP_FOR_INIT (inner_for_stmt), j);
4353 : 0 : gcc_assert (TREE_CODE (t) == MODIFY_EXPR);
4354 : 0 : TREE_VEC_ELT (OMP_FOR_ORIG_DECLS (for_stmt), i + j)
4355 : 0 : = TREE_OPERAND (t, 0);
4356 : : }
4357 : : }
4358 : 1661 : TREE_VEC_ELT (OMP_FOR_INIT (for_stmt), i + j)
4359 : 1661 : = TREE_VEC_ELT (OMP_FOR_INIT (inner_for_stmt), j);
4360 : 1661 : TREE_VEC_ELT (OMP_FOR_COND (for_stmt), i + j)
4361 : 1661 : = TREE_VEC_ELT (OMP_FOR_COND (inner_for_stmt), j);
4362 : 1661 : TREE_VEC_ELT (OMP_FOR_INCR (for_stmt), i + j)
4363 : 1661 : = TREE_VEC_ELT (OMP_FOR_INCR (inner_for_stmt), j);
4364 : 1661 : TREE_VEC_ELT (OMP_FOR_INIT (inner_for_stmt), j) = NULL_TREE;
4365 : 1661 : TREE_VEC_ELT (OMP_FOR_COND (inner_for_stmt), j) = NULL_TREE;
4366 : 1661 : TREE_VEC_ELT (OMP_FOR_INCR (inner_for_stmt), j) = NULL_TREE;
4367 : : }
4368 : : }
4369 : : }
4370 : :
4371 : 56749 : switch (TREE_CODE (for_stmt))
4372 : : {
4373 : 1165 : case OMP_TILE:
4374 : 1165 : tree sizes;
4375 : 1165 : sizes = omp_find_clause (OMP_FOR_CLAUSES (for_stmt), OMP_CLAUSE_SIZES);
4376 : 1165 : omp_apply_tile (for_stmt, OMP_CLAUSE_SIZES_LIST (sizes), 0);
4377 : 1165 : OMP_LOOPXFORM_LOWERED (for_stmt) = 1;
4378 : 1165 : break;
4379 : 1109 : case OMP_UNROLL:
4380 : 1109 : tree partial;
4381 : 1109 : partial = omp_find_clause (OMP_FOR_CLAUSES (for_stmt),
4382 : : OMP_CLAUSE_PARTIAL);
4383 : 1109 : if (partial)
4384 : 793 : omp_apply_tile (for_stmt, NULL_TREE,
4385 : 793 : OMP_CLAUSE_PARTIAL_EXPR (partial)
4386 : 609 : ? tree_to_shwi (OMP_CLAUSE_PARTIAL_EXPR (partial))
4387 : : : 8);
4388 : 316 : else if (omp_find_clause (OMP_FOR_CLAUSES (for_stmt), OMP_CLAUSE_FULL))
4389 : : {
4390 : 274 : tree iters = omp_loop_number_of_iterations (for_stmt, 0, NULL);
4391 : 274 : if (TREE_CODE (iters) != INTEGER_CST)
4392 : 12 : error_at (EXPR_LOCATION (for_stmt),
4393 : : "non-constant iteration count of %<unroll full%> loop");
4394 : : }
4395 : 1109 : OMP_LOOPXFORM_LOWERED (for_stmt) = 1;
4396 : 1109 : break;
4397 : : default:
4398 : : break;
4399 : : }
4400 : : }
4401 : :
4402 : : #include "gt-omp-general.h"
|
