comparison gcc/omp-general.c @ 16:04ced10e8804

gcc 7
author kono
date Fri, 27 Oct 2017 22:46:09 +0900
parents
children 84e7813d76e9
comparison
equal deleted inserted replaced
15:561a7518be6b 16:04ced10e8804
1 /* General types and functions that are uselful for processing of OpenMP,
2 OpenACC and similar directivers at various stages of compilation.
3
4 Copyright (C) 2005-2017 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 /* Find an OMP clause of type KIND within CLAUSES. */
23
24 #include "config.h"
25 #include "system.h"
26 #include "coretypes.h"
27 #include "backend.h"
28 #include "target.h"
29 #include "tree.h"
30 #include "gimple.h"
31 #include "ssa.h"
32 #include "diagnostic-core.h"
33 #include "fold-const.h"
34 #include "langhooks.h"
35 #include "omp-general.h"
36 #include "stringpool.h"
37 #include "attribs.h"
38
39 tree
40 omp_find_clause (tree clauses, enum omp_clause_code kind)
41 {
42 for (; clauses ; clauses = OMP_CLAUSE_CHAIN (clauses))
43 if (OMP_CLAUSE_CODE (clauses) == kind)
44 return clauses;
45
46 return NULL_TREE;
47 }
48
49 /* Return true if DECL is a reference type. */
50
51 bool
52 omp_is_reference (tree decl)
53 {
54 return lang_hooks.decls.omp_privatize_by_reference (decl);
55 }
56
57 /* Adjust *COND_CODE and *N2 so that the former is either LT_EXPR or
58 GT_EXPR. */
59
60 void
61 omp_adjust_for_condition (location_t loc, enum tree_code *cond_code, tree *n2)
62 {
63 switch (*cond_code)
64 {
65 case LT_EXPR:
66 case GT_EXPR:
67 case NE_EXPR:
68 break;
69 case LE_EXPR:
70 if (POINTER_TYPE_P (TREE_TYPE (*n2)))
71 *n2 = fold_build_pointer_plus_hwi_loc (loc, *n2, 1);
72 else
73 *n2 = fold_build2_loc (loc, PLUS_EXPR, TREE_TYPE (*n2), *n2,
74 build_int_cst (TREE_TYPE (*n2), 1));
75 *cond_code = LT_EXPR;
76 break;
77 case GE_EXPR:
78 if (POINTER_TYPE_P (TREE_TYPE (*n2)))
79 *n2 = fold_build_pointer_plus_hwi_loc (loc, *n2, -1);
80 else
81 *n2 = fold_build2_loc (loc, MINUS_EXPR, TREE_TYPE (*n2), *n2,
82 build_int_cst (TREE_TYPE (*n2), 1));
83 *cond_code = GT_EXPR;
84 break;
85 default:
86 gcc_unreachable ();
87 }
88 }
89
90 /* Return the looping step from INCR, extracted from the step of a gimple omp
91 for statement. */
92
93 tree
94 omp_get_for_step_from_incr (location_t loc, tree incr)
95 {
96 tree step;
97 switch (TREE_CODE (incr))
98 {
99 case PLUS_EXPR:
100 step = TREE_OPERAND (incr, 1);
101 break;
102 case POINTER_PLUS_EXPR:
103 step = fold_convert (ssizetype, TREE_OPERAND (incr, 1));
104 break;
105 case MINUS_EXPR:
106 step = TREE_OPERAND (incr, 1);
107 step = fold_build1_loc (loc, NEGATE_EXPR, TREE_TYPE (step), step);
108 break;
109 default:
110 gcc_unreachable ();
111 }
112 return step;
113 }
114
115 /* Extract the header elements of parallel loop FOR_STMT and store
116 them into *FD. */
117
118 void
119 omp_extract_for_data (gomp_for *for_stmt, struct omp_for_data *fd,
120 struct omp_for_data_loop *loops)
121 {
122 tree t, var, *collapse_iter, *collapse_count;
123 tree count = NULL_TREE, iter_type = long_integer_type_node;
124 struct omp_for_data_loop *loop;
125 int i;
126 struct omp_for_data_loop dummy_loop;
127 location_t loc = gimple_location (for_stmt);
128 bool simd = gimple_omp_for_kind (for_stmt) & GF_OMP_FOR_SIMD;
129 bool distribute = gimple_omp_for_kind (for_stmt)
130 == GF_OMP_FOR_KIND_DISTRIBUTE;
131 bool taskloop = gimple_omp_for_kind (for_stmt)
132 == GF_OMP_FOR_KIND_TASKLOOP;
133 tree iterv, countv;
134
135 fd->for_stmt = for_stmt;
136 fd->pre = NULL;
137 fd->have_nowait = distribute || simd;
138 fd->have_ordered = false;
139 fd->tiling = NULL_TREE;
140 fd->collapse = 1;
141 fd->ordered = 0;
142 fd->sched_kind = OMP_CLAUSE_SCHEDULE_STATIC;
143 fd->sched_modifiers = 0;
144 fd->chunk_size = NULL_TREE;
145 fd->simd_schedule = false;
146 if (gimple_omp_for_kind (fd->for_stmt) == GF_OMP_FOR_KIND_CILKFOR)
147 fd->sched_kind = OMP_CLAUSE_SCHEDULE_CILKFOR;
148 collapse_iter = NULL;
149 collapse_count = NULL;
150
151 for (t = gimple_omp_for_clauses (for_stmt); t ; t = OMP_CLAUSE_CHAIN (t))
152 switch (OMP_CLAUSE_CODE (t))
153 {
154 case OMP_CLAUSE_NOWAIT:
155 fd->have_nowait = true;
156 break;
157 case OMP_CLAUSE_ORDERED:
158 fd->have_ordered = true;
159 if (OMP_CLAUSE_ORDERED_EXPR (t))
160 fd->ordered = tree_to_shwi (OMP_CLAUSE_ORDERED_EXPR (t));
161 break;
162 case OMP_CLAUSE_SCHEDULE:
163 gcc_assert (!distribute && !taskloop);
164 fd->sched_kind
165 = (enum omp_clause_schedule_kind)
166 (OMP_CLAUSE_SCHEDULE_KIND (t) & OMP_CLAUSE_SCHEDULE_MASK);
167 fd->sched_modifiers = (OMP_CLAUSE_SCHEDULE_KIND (t)
168 & ~OMP_CLAUSE_SCHEDULE_MASK);
169 fd->chunk_size = OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (t);
170 fd->simd_schedule = OMP_CLAUSE_SCHEDULE_SIMD (t);
171 break;
172 case OMP_CLAUSE_DIST_SCHEDULE:
173 gcc_assert (distribute);
174 fd->chunk_size = OMP_CLAUSE_DIST_SCHEDULE_CHUNK_EXPR (t);
175 break;
176 case OMP_CLAUSE_COLLAPSE:
177 fd->collapse = tree_to_shwi (OMP_CLAUSE_COLLAPSE_EXPR (t));
178 if (fd->collapse > 1)
179 {
180 collapse_iter = &OMP_CLAUSE_COLLAPSE_ITERVAR (t);
181 collapse_count = &OMP_CLAUSE_COLLAPSE_COUNT (t);
182 }
183 break;
184 case OMP_CLAUSE_TILE:
185 fd->tiling = OMP_CLAUSE_TILE_LIST (t);
186 fd->collapse = list_length (fd->tiling);
187 gcc_assert (fd->collapse);
188 collapse_iter = &OMP_CLAUSE_TILE_ITERVAR (t);
189 collapse_count = &OMP_CLAUSE_TILE_COUNT (t);
190 break;
191 default:
192 break;
193 }
194
195 if (fd->collapse > 1 || fd->tiling)
196 fd->loops = loops;
197 else
198 fd->loops = &fd->loop;
199
200 if (fd->ordered && fd->collapse == 1 && loops != NULL)
201 {
202 fd->loops = loops;
203 iterv = NULL_TREE;
204 countv = NULL_TREE;
205 collapse_iter = &iterv;
206 collapse_count = &countv;
207 }
208
209 /* FIXME: for now map schedule(auto) to schedule(static).
210 There should be analysis to determine whether all iterations
211 are approximately the same amount of work (then schedule(static)
212 is best) or if it varies (then schedule(dynamic,N) is better). */
213 if (fd->sched_kind == OMP_CLAUSE_SCHEDULE_AUTO)
214 {
215 fd->sched_kind = OMP_CLAUSE_SCHEDULE_STATIC;
216 gcc_assert (fd->chunk_size == NULL);
217 }
218 gcc_assert ((fd->collapse == 1 && !fd->tiling) || collapse_iter != NULL);
219 if (taskloop)
220 fd->sched_kind = OMP_CLAUSE_SCHEDULE_RUNTIME;
221 if (fd->sched_kind == OMP_CLAUSE_SCHEDULE_RUNTIME)
222 gcc_assert (fd->chunk_size == NULL);
223 else if (fd->chunk_size == NULL)
224 {
225 /* We only need to compute a default chunk size for ordered
226 static loops and dynamic loops. */
227 if (fd->sched_kind != OMP_CLAUSE_SCHEDULE_STATIC
228 || fd->have_ordered)
229 fd->chunk_size = (fd->sched_kind == OMP_CLAUSE_SCHEDULE_STATIC)
230 ? integer_zero_node : integer_one_node;
231 }
232
233 int cnt = fd->ordered ? fd->ordered : fd->collapse;
234 for (i = 0; i < cnt; i++)
235 {
236 if (i == 0
237 && fd->collapse == 1
238 && !fd->tiling
239 && (fd->ordered == 0 || loops == NULL))
240 loop = &fd->loop;
241 else if (loops != NULL)
242 loop = loops + i;
243 else
244 loop = &dummy_loop;
245
246 loop->v = gimple_omp_for_index (for_stmt, i);
247 gcc_assert (SSA_VAR_P (loop->v));
248 gcc_assert (TREE_CODE (TREE_TYPE (loop->v)) == INTEGER_TYPE
249 || TREE_CODE (TREE_TYPE (loop->v)) == POINTER_TYPE);
250 var = TREE_CODE (loop->v) == SSA_NAME ? SSA_NAME_VAR (loop->v) : loop->v;
251 loop->n1 = gimple_omp_for_initial (for_stmt, i);
252
253 loop->cond_code = gimple_omp_for_cond (for_stmt, i);
254 loop->n2 = gimple_omp_for_final (for_stmt, i);
255 gcc_assert (loop->cond_code != NE_EXPR
256 || gimple_omp_for_kind (for_stmt) == GF_OMP_FOR_KIND_CILKSIMD
257 || gimple_omp_for_kind (for_stmt) == GF_OMP_FOR_KIND_CILKFOR);
258 omp_adjust_for_condition (loc, &loop->cond_code, &loop->n2);
259
260 t = gimple_omp_for_incr (for_stmt, i);
261 gcc_assert (TREE_OPERAND (t, 0) == var);
262 loop->step = omp_get_for_step_from_incr (loc, t);
263
264 if (simd
265 || (fd->sched_kind == OMP_CLAUSE_SCHEDULE_STATIC
266 && !fd->have_ordered))
267 {
268 if (fd->collapse == 1 && !fd->tiling)
269 iter_type = TREE_TYPE (loop->v);
270 else if (i == 0
271 || TYPE_PRECISION (iter_type)
272 < TYPE_PRECISION (TREE_TYPE (loop->v)))
273 iter_type
274 = build_nonstandard_integer_type
275 (TYPE_PRECISION (TREE_TYPE (loop->v)), 1);
276 }
277 else if (iter_type != long_long_unsigned_type_node)
278 {
279 if (POINTER_TYPE_P (TREE_TYPE (loop->v)))
280 iter_type = long_long_unsigned_type_node;
281 else if (TYPE_UNSIGNED (TREE_TYPE (loop->v))
282 && TYPE_PRECISION (TREE_TYPE (loop->v))
283 >= TYPE_PRECISION (iter_type))
284 {
285 tree n;
286
287 if (loop->cond_code == LT_EXPR)
288 n = fold_build2_loc (loc,
289 PLUS_EXPR, TREE_TYPE (loop->v),
290 loop->n2, loop->step);
291 else
292 n = loop->n1;
293 if (TREE_CODE (n) != INTEGER_CST
294 || tree_int_cst_lt (TYPE_MAX_VALUE (iter_type), n))
295 iter_type = long_long_unsigned_type_node;
296 }
297 else if (TYPE_PRECISION (TREE_TYPE (loop->v))
298 > TYPE_PRECISION (iter_type))
299 {
300 tree n1, n2;
301
302 if (loop->cond_code == LT_EXPR)
303 {
304 n1 = loop->n1;
305 n2 = fold_build2_loc (loc,
306 PLUS_EXPR, TREE_TYPE (loop->v),
307 loop->n2, loop->step);
308 }
309 else
310 {
311 n1 = fold_build2_loc (loc,
312 MINUS_EXPR, TREE_TYPE (loop->v),
313 loop->n2, loop->step);
314 n2 = loop->n1;
315 }
316 if (TREE_CODE (n1) != INTEGER_CST
317 || TREE_CODE (n2) != INTEGER_CST
318 || !tree_int_cst_lt (TYPE_MIN_VALUE (iter_type), n1)
319 || !tree_int_cst_lt (n2, TYPE_MAX_VALUE (iter_type)))
320 iter_type = long_long_unsigned_type_node;
321 }
322 }
323
324 if (i >= fd->collapse)
325 continue;
326
327 if (collapse_count && *collapse_count == NULL)
328 {
329 t = fold_binary (loop->cond_code, boolean_type_node,
330 fold_convert (TREE_TYPE (loop->v), loop->n1),
331 fold_convert (TREE_TYPE (loop->v), loop->n2));
332 if (t && integer_zerop (t))
333 count = build_zero_cst (long_long_unsigned_type_node);
334 else if ((i == 0 || count != NULL_TREE)
335 && TREE_CODE (TREE_TYPE (loop->v)) == INTEGER_TYPE
336 && TREE_CONSTANT (loop->n1)
337 && TREE_CONSTANT (loop->n2)
338 && TREE_CODE (loop->step) == INTEGER_CST)
339 {
340 tree itype = TREE_TYPE (loop->v);
341
342 if (POINTER_TYPE_P (itype))
343 itype = signed_type_for (itype);
344 t = build_int_cst (itype, (loop->cond_code == LT_EXPR ? -1 : 1));
345 t = fold_build2_loc (loc,
346 PLUS_EXPR, itype,
347 fold_convert_loc (loc, itype, loop->step), t);
348 t = fold_build2_loc (loc, PLUS_EXPR, itype, t,
349 fold_convert_loc (loc, itype, loop->n2));
350 t = fold_build2_loc (loc, MINUS_EXPR, itype, t,
351 fold_convert_loc (loc, itype, loop->n1));
352 if (TYPE_UNSIGNED (itype) && loop->cond_code == GT_EXPR)
353 t = fold_build2_loc (loc, TRUNC_DIV_EXPR, itype,
354 fold_build1_loc (loc, NEGATE_EXPR, itype, t),
355 fold_build1_loc (loc, NEGATE_EXPR, itype,
356 fold_convert_loc (loc, itype,
357 loop->step)));
358 else
359 t = fold_build2_loc (loc, TRUNC_DIV_EXPR, itype, t,
360 fold_convert_loc (loc, itype, loop->step));
361 t = fold_convert_loc (loc, long_long_unsigned_type_node, t);
362 if (count != NULL_TREE)
363 count = fold_build2_loc (loc,
364 MULT_EXPR, long_long_unsigned_type_node,
365 count, t);
366 else
367 count = t;
368 if (TREE_CODE (count) != INTEGER_CST)
369 count = NULL_TREE;
370 }
371 else if (count && !integer_zerop (count))
372 count = NULL_TREE;
373 }
374 }
375
376 if (count
377 && !simd
378 && (fd->sched_kind != OMP_CLAUSE_SCHEDULE_STATIC
379 || fd->have_ordered))
380 {
381 if (!tree_int_cst_lt (count, TYPE_MAX_VALUE (long_integer_type_node)))
382 iter_type = long_long_unsigned_type_node;
383 else
384 iter_type = long_integer_type_node;
385 }
386 else if (collapse_iter && *collapse_iter != NULL)
387 iter_type = TREE_TYPE (*collapse_iter);
388 fd->iter_type = iter_type;
389 if (collapse_iter && *collapse_iter == NULL)
390 *collapse_iter = create_tmp_var (iter_type, ".iter");
391 if (collapse_count && *collapse_count == NULL)
392 {
393 if (count)
394 *collapse_count = fold_convert_loc (loc, iter_type, count);
395 else
396 *collapse_count = create_tmp_var (iter_type, ".count");
397 }
398
399 if (fd->collapse > 1 || fd->tiling || (fd->ordered && loops))
400 {
401 fd->loop.v = *collapse_iter;
402 fd->loop.n1 = build_int_cst (TREE_TYPE (fd->loop.v), 0);
403 fd->loop.n2 = *collapse_count;
404 fd->loop.step = build_int_cst (TREE_TYPE (fd->loop.v), 1);
405 fd->loop.cond_code = LT_EXPR;
406 }
407 else if (loops)
408 loops[0] = fd->loop;
409 }
410
411 /* Build a call to GOMP_barrier. */
412
413 gimple *
414 omp_build_barrier (tree lhs)
415 {
416 tree fndecl = builtin_decl_explicit (lhs ? BUILT_IN_GOMP_BARRIER_CANCEL
417 : BUILT_IN_GOMP_BARRIER);
418 gcall *g = gimple_build_call (fndecl, 0);
419 if (lhs)
420 gimple_call_set_lhs (g, lhs);
421 return g;
422 }
423
424 /* Return maximum possible vectorization factor for the target. */
425
426 int
427 omp_max_vf (void)
428 {
429 if (!optimize
430 || optimize_debug
431 || !flag_tree_loop_optimize
432 || (!flag_tree_loop_vectorize
433 && global_options_set.x_flag_tree_loop_vectorize))
434 return 1;
435
436 int vf = 1;
437 int vs = targetm.vectorize.autovectorize_vector_sizes ();
438 if (vs)
439 vf = 1 << floor_log2 (vs);
440 else
441 {
442 machine_mode vqimode = targetm.vectorize.preferred_simd_mode (QImode);
443 if (GET_MODE_CLASS (vqimode) == MODE_VECTOR_INT)
444 vf = GET_MODE_NUNITS (vqimode);
445 }
446 return vf;
447 }
448
449 /* Return maximum SIMT width if offloading may target SIMT hardware. */
450
451 int
452 omp_max_simt_vf (void)
453 {
454 if (!optimize)
455 return 0;
456 if (ENABLE_OFFLOADING)
457 for (const char *c = getenv ("OFFLOAD_TARGET_NAMES"); c;)
458 {
459 if (!strncmp (c, "nvptx", strlen ("nvptx")))
460 return 32;
461 else if ((c = strchr (c, ',')))
462 c++;
463 }
464 return 0;
465 }
466
467 /* Encode an oacc launch argument. This matches the GOMP_LAUNCH_PACK
468 macro on gomp-constants.h. We do not check for overflow. */
469
470 tree
471 oacc_launch_pack (unsigned code, tree device, unsigned op)
472 {
473 tree res;
474
475 res = build_int_cst (unsigned_type_node, GOMP_LAUNCH_PACK (code, 0, op));
476 if (device)
477 {
478 device = fold_build2 (LSHIFT_EXPR, unsigned_type_node,
479 device, build_int_cst (unsigned_type_node,
480 GOMP_LAUNCH_DEVICE_SHIFT));
481 res = fold_build2 (BIT_IOR_EXPR, unsigned_type_node, res, device);
482 }
483 return res;
484 }
485
486 /* FIXME: What is the following comment for? */
487 /* Look for compute grid dimension clauses and convert to an attribute
488 attached to FN. This permits the target-side code to (a) massage
489 the dimensions, (b) emit that data and (c) optimize. Non-constant
490 dimensions are pushed onto ARGS.
491
492 The attribute value is a TREE_LIST. A set of dimensions is
493 represented as a list of INTEGER_CST. Those that are runtime
494 exprs are represented as an INTEGER_CST of zero.
495
496 TODO: Normally the attribute will just contain a single such list. If
497 however it contains a list of lists, this will represent the use of
498 device_type. Each member of the outer list is an assoc list of
499 dimensions, keyed by the device type. The first entry will be the
500 default. Well, that's the plan. */
501
502 /* Replace any existing oacc fn attribute with updated dimensions. */
503
504 void
505 oacc_replace_fn_attrib (tree fn, tree dims)
506 {
507 tree ident = get_identifier (OACC_FN_ATTRIB);
508 tree attribs = DECL_ATTRIBUTES (fn);
509
510 /* If we happen to be present as the first attrib, drop it. */
511 if (attribs && TREE_PURPOSE (attribs) == ident)
512 attribs = TREE_CHAIN (attribs);
513 DECL_ATTRIBUTES (fn) = tree_cons (ident, dims, attribs);
514 }
515
516 /* Scan CLAUSES for launch dimensions and attach them to the oacc
517 function attribute. Push any that are non-constant onto the ARGS
518 list, along with an appropriate GOMP_LAUNCH_DIM tag. */
519
520 void
521 oacc_set_fn_attrib (tree fn, tree clauses, vec<tree> *args)
522 {
523 /* Must match GOMP_DIM ordering. */
524 static const omp_clause_code ids[]
525 = { OMP_CLAUSE_NUM_GANGS, OMP_CLAUSE_NUM_WORKERS,
526 OMP_CLAUSE_VECTOR_LENGTH };
527 unsigned ix;
528 tree dims[GOMP_DIM_MAX];
529
530 tree attr = NULL_TREE;
531 unsigned non_const = 0;
532
533 for (ix = GOMP_DIM_MAX; ix--;)
534 {
535 tree clause = omp_find_clause (clauses, ids[ix]);
536 tree dim = NULL_TREE;
537
538 if (clause)
539 dim = OMP_CLAUSE_EXPR (clause, ids[ix]);
540 dims[ix] = dim;
541 if (dim && TREE_CODE (dim) != INTEGER_CST)
542 {
543 dim = integer_zero_node;
544 non_const |= GOMP_DIM_MASK (ix);
545 }
546 attr = tree_cons (NULL_TREE, dim, attr);
547 }
548
549 oacc_replace_fn_attrib (fn, attr);
550
551 if (non_const)
552 {
553 /* Push a dynamic argument set. */
554 args->safe_push (oacc_launch_pack (GOMP_LAUNCH_DIM,
555 NULL_TREE, non_const));
556 for (unsigned ix = 0; ix != GOMP_DIM_MAX; ix++)
557 if (non_const & GOMP_DIM_MASK (ix))
558 args->safe_push (dims[ix]);
559 }
560 }
561
562 /* Process the routine's dimension clauess to generate an attribute
563 value. Issue diagnostics as appropriate. We default to SEQ
564 (OpenACC 2.5 clarifies this). All dimensions have a size of zero
565 (dynamic). TREE_PURPOSE is set to indicate whether that dimension
566 can have a loop partitioned on it. non-zero indicates
567 yes, zero indicates no. By construction once a non-zero has been
568 reached, further inner dimensions must also be non-zero. We set
569 TREE_VALUE to zero for the dimensions that may be partitioned and
570 1 for the other ones -- if a loop is (erroneously) spawned at
571 an outer level, we don't want to try and partition it. */
572
573 tree
574 oacc_build_routine_dims (tree clauses)
575 {
576 /* Must match GOMP_DIM ordering. */
577 static const omp_clause_code ids[]
578 = {OMP_CLAUSE_GANG, OMP_CLAUSE_WORKER, OMP_CLAUSE_VECTOR, OMP_CLAUSE_SEQ};
579 int ix;
580 int level = -1;
581
582 for (; clauses; clauses = OMP_CLAUSE_CHAIN (clauses))
583 for (ix = GOMP_DIM_MAX + 1; ix--;)
584 if (OMP_CLAUSE_CODE (clauses) == ids[ix])
585 {
586 if (level >= 0)
587 error_at (OMP_CLAUSE_LOCATION (clauses),
588 "multiple loop axes specified for routine");
589 level = ix;
590 break;
591 }
592
593 /* Default to SEQ. */
594 if (level < 0)
595 level = GOMP_DIM_MAX;
596
597 tree dims = NULL_TREE;
598
599 for (ix = GOMP_DIM_MAX; ix--;)
600 dims = tree_cons (build_int_cst (boolean_type_node, ix >= level),
601 build_int_cst (integer_type_node, ix < level), dims);
602
603 return dims;
604 }
605
606 /* Retrieve the oacc function attrib and return it. Non-oacc
607 functions will return NULL. */
608
609 tree
610 oacc_get_fn_attrib (tree fn)
611 {
612 return lookup_attribute (OACC_FN_ATTRIB, DECL_ATTRIBUTES (fn));
613 }
614
615 /* Extract an oacc execution dimension from FN. FN must be an
616 offloaded function or routine that has already had its execution
617 dimensions lowered to the target-specific values. */
618
619 int
620 oacc_get_fn_dim_size (tree fn, int axis)
621 {
622 tree attrs = oacc_get_fn_attrib (fn);
623
624 gcc_assert (axis < GOMP_DIM_MAX);
625
626 tree dims = TREE_VALUE (attrs);
627 while (axis--)
628 dims = TREE_CHAIN (dims);
629
630 int size = TREE_INT_CST_LOW (TREE_VALUE (dims));
631
632 return size;
633 }
634
635 /* Extract the dimension axis from an IFN_GOACC_DIM_POS or
636 IFN_GOACC_DIM_SIZE call. */
637
638 int
639 oacc_get_ifn_dim_arg (const gimple *stmt)
640 {
641 gcc_checking_assert (gimple_call_internal_fn (stmt) == IFN_GOACC_DIM_SIZE
642 || gimple_call_internal_fn (stmt) == IFN_GOACC_DIM_POS);
643 tree arg = gimple_call_arg (stmt, 0);
644 HOST_WIDE_INT axis = TREE_INT_CST_LOW (arg);
645
646 gcc_checking_assert (axis >= 0 && axis < GOMP_DIM_MAX);
647 return (int) axis;
648 }