|
111
|
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 }
|
