1 /* This file contains routines to construct GNU OpenMP constructs,
2 called from parsing in the C and C++ front ends.
4 Copyright (C) 2005, 2007, 2008, 2009 Free Software Foundation, Inc.
5 Contributed by Richard Henderson <rth@redhat.com>,
6 Diego Novillo <dnovillo@redhat.com>.
8 This file is part of GCC.
10 GCC is free software; you can redistribute it and/or modify it under
11 the terms of the GNU General Public License as published by the Free
12 Software Foundation; either version 3, or (at your option) any later
15 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
16 WARRANTY; without even the implied warranty of MERCHANTABILITY or
17 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
20 You should have received a copy of the GNU General Public License
21 along with GCC; see the file COPYING3. If not see
22 <http://www.gnu.org/licenses/>. */
26 #include "coretypes.h"
34 #include "langhooks.h"
37 /* Complete a #pragma omp master construct. STMT is the structured-block
38 that follows the pragma. */
41 c_finish_omp_master (tree stmt
)
43 return add_stmt (build1 (OMP_MASTER
, void_type_node
, stmt
));
46 /* Complete a #pragma omp critical construct. STMT is the structured-block
47 that follows the pragma, NAME is the identifier in the pragma, or null
51 c_finish_omp_critical (tree body
, tree name
)
53 tree stmt
= make_node (OMP_CRITICAL
);
54 TREE_TYPE (stmt
) = void_type_node
;
55 OMP_CRITICAL_BODY (stmt
) = body
;
56 OMP_CRITICAL_NAME (stmt
) = name
;
57 return add_stmt (stmt
);
60 /* Complete a #pragma omp ordered construct. STMT is the structured-block
61 that follows the pragma. */
64 c_finish_omp_ordered (tree stmt
)
66 return add_stmt (build1 (OMP_ORDERED
, void_type_node
, stmt
));
70 /* Complete a #pragma omp barrier construct. */
73 c_finish_omp_barrier (void)
77 x
= built_in_decls
[BUILT_IN_GOMP_BARRIER
];
78 x
= build_call_expr (x
, 0);
83 /* Complete a #pragma omp taskwait construct. */
86 c_finish_omp_taskwait (void)
90 x
= built_in_decls
[BUILT_IN_GOMP_TASKWAIT
];
91 x
= build_call_expr (x
, 0);
96 /* Complete a #pragma omp atomic construct. The expression to be
97 implemented atomically is LHS code= RHS. The value returned is
98 either error_mark_node (if the construct was erroneous) or an
99 OMP_ATOMIC node which should be added to the current statement tree
103 c_finish_omp_atomic (enum tree_code code
, tree lhs
, tree rhs
)
107 if (lhs
== error_mark_node
|| rhs
== error_mark_node
)
108 return error_mark_node
;
110 /* ??? According to one reading of the OpenMP spec, complex type are
111 supported, but there are no atomic stores for any architecture.
112 But at least icc 9.0 doesn't support complex types here either.
113 And lets not even talk about vector types... */
114 type
= TREE_TYPE (lhs
);
115 if (!INTEGRAL_TYPE_P (type
)
116 && !POINTER_TYPE_P (type
)
117 && !SCALAR_FLOAT_TYPE_P (type
))
119 error ("invalid expression type for %<#pragma omp atomic%>");
120 return error_mark_node
;
123 /* ??? Validate that rhs does not overlap lhs. */
125 /* Take and save the address of the lhs. From then on we'll reference it
127 addr
= build_unary_op (input_location
, ADDR_EXPR
, lhs
, 0);
128 if (addr
== error_mark_node
)
129 return error_mark_node
;
130 addr
= save_expr (addr
);
131 if (TREE_CODE (addr
) != SAVE_EXPR
132 && (TREE_CODE (addr
) != ADDR_EXPR
133 || TREE_CODE (TREE_OPERAND (addr
, 0)) != VAR_DECL
))
135 /* Make sure LHS is simple enough so that goa_lhs_expr_p can recognize
136 it even after unsharing function body. */
137 tree var
= create_tmp_var_raw (TREE_TYPE (addr
), NULL
);
138 addr
= build4 (TARGET_EXPR
, TREE_TYPE (addr
), var
, addr
, NULL
, NULL
);
140 lhs
= build_indirect_ref (input_location
, addr
, NULL
);
142 /* There are lots of warnings, errors, and conversions that need to happen
143 in the course of interpreting a statement. Use the normal mechanisms
144 to do this, and then take it apart again. */
145 x
= build_modify_expr (input_location
, lhs
, NULL_TREE
, code
, rhs
, NULL_TREE
);
146 if (x
== error_mark_node
)
147 return error_mark_node
;
148 gcc_assert (TREE_CODE (x
) == MODIFY_EXPR
);
149 rhs
= TREE_OPERAND (x
, 1);
151 /* Punt the actual generation of atomic operations to common code. */
152 return build2 (OMP_ATOMIC
, void_type_node
, addr
, rhs
);
156 /* Complete a #pragma omp flush construct. We don't do anything with the
157 variable list that the syntax allows. */
160 c_finish_omp_flush (void)
164 x
= built_in_decls
[BUILT_IN_SYNCHRONIZE
];
165 x
= build_call_expr (x
, 0);
170 /* Check and canonicalize #pragma omp for increment expression.
171 Helper function for c_finish_omp_for. */
174 check_omp_for_incr_expr (tree exp
, tree decl
)
178 if (!INTEGRAL_TYPE_P (TREE_TYPE (exp
))
179 || TYPE_PRECISION (TREE_TYPE (exp
)) < TYPE_PRECISION (TREE_TYPE (decl
)))
180 return error_mark_node
;
183 return build_int_cst (TREE_TYPE (exp
), 0);
185 switch (TREE_CODE (exp
))
188 t
= check_omp_for_incr_expr (TREE_OPERAND (exp
, 0), decl
);
189 if (t
!= error_mark_node
)
190 return fold_convert (TREE_TYPE (exp
), t
);
193 t
= check_omp_for_incr_expr (TREE_OPERAND (exp
, 0), decl
);
194 if (t
!= error_mark_node
)
195 return fold_build2 (MINUS_EXPR
, TREE_TYPE (exp
), t
, TREE_OPERAND (exp
, 1));
198 t
= check_omp_for_incr_expr (TREE_OPERAND (exp
, 0), decl
);
199 if (t
!= error_mark_node
)
200 return fold_build2 (PLUS_EXPR
, TREE_TYPE (exp
), t
, TREE_OPERAND (exp
, 1));
201 t
= check_omp_for_incr_expr (TREE_OPERAND (exp
, 1), decl
);
202 if (t
!= error_mark_node
)
203 return fold_build2 (PLUS_EXPR
, TREE_TYPE (exp
), TREE_OPERAND (exp
, 0), t
);
209 return error_mark_node
;
212 /* Validate and emit code for the OpenMP directive #pragma omp for.
213 DECLV is a vector of iteration variables, for each collapsed loop.
214 INITV, CONDV and INCRV are vectors containing initialization
215 expressions, controlling predicates and increment expressions.
216 BODY is the body of the loop and PRE_BODY statements that go before
220 c_finish_omp_for (location_t locus
, tree declv
, tree initv
, tree condv
,
221 tree incrv
, tree body
, tree pre_body
)
227 gcc_assert (TREE_VEC_LENGTH (declv
) == TREE_VEC_LENGTH (initv
));
228 gcc_assert (TREE_VEC_LENGTH (declv
) == TREE_VEC_LENGTH (condv
));
229 gcc_assert (TREE_VEC_LENGTH (declv
) == TREE_VEC_LENGTH (incrv
));
230 for (i
= 0; i
< TREE_VEC_LENGTH (declv
); i
++)
232 tree decl
= TREE_VEC_ELT (declv
, i
);
233 tree init
= TREE_VEC_ELT (initv
, i
);
234 tree cond
= TREE_VEC_ELT (condv
, i
);
235 tree incr
= TREE_VEC_ELT (incrv
, i
);
238 if (EXPR_HAS_LOCATION (init
))
239 elocus
= EXPR_LOCATION (init
);
241 /* Validate the iteration variable. */
242 if (!INTEGRAL_TYPE_P (TREE_TYPE (decl
))
243 && TREE_CODE (TREE_TYPE (decl
)) != POINTER_TYPE
)
245 error_at (elocus
, "invalid type for iteration variable %qE", decl
);
249 /* In the case of "for (int i = 0...)", init will be a decl. It should
250 have a DECL_INITIAL that we can turn into an assignment. */
253 elocus
= DECL_SOURCE_LOCATION (decl
);
255 init
= DECL_INITIAL (decl
);
258 error_at (elocus
, "%qE is not initialized", decl
);
259 init
= integer_zero_node
;
263 init
= build_modify_expr (elocus
, decl
, NULL_TREE
, NOP_EXPR
, init
,
266 gcc_assert (TREE_CODE (init
) == MODIFY_EXPR
);
267 gcc_assert (TREE_OPERAND (init
, 0) == decl
);
269 if (cond
== NULL_TREE
)
271 error_at (elocus
, "missing controlling predicate");
276 bool cond_ok
= false;
278 if (EXPR_HAS_LOCATION (cond
))
279 elocus
= EXPR_LOCATION (cond
);
281 if (TREE_CODE (cond
) == LT_EXPR
282 || TREE_CODE (cond
) == LE_EXPR
283 || TREE_CODE (cond
) == GT_EXPR
284 || TREE_CODE (cond
) == GE_EXPR
285 || TREE_CODE (cond
) == NE_EXPR
)
287 tree op0
= TREE_OPERAND (cond
, 0);
288 tree op1
= TREE_OPERAND (cond
, 1);
290 /* 2.5.1. The comparison in the condition is computed in
291 the type of DECL, otherwise the behavior is undefined.
297 according to ISO will be evaluated as:
302 if (TREE_CODE (op0
) == NOP_EXPR
303 && decl
== TREE_OPERAND (op0
, 0))
305 TREE_OPERAND (cond
, 0) = TREE_OPERAND (op0
, 0);
306 TREE_OPERAND (cond
, 1)
307 = fold_build1 (NOP_EXPR
, TREE_TYPE (decl
),
308 TREE_OPERAND (cond
, 1));
310 else if (TREE_CODE (op1
) == NOP_EXPR
311 && decl
== TREE_OPERAND (op1
, 0))
313 TREE_OPERAND (cond
, 1) = TREE_OPERAND (op1
, 0);
314 TREE_OPERAND (cond
, 0)
315 = fold_build1 (NOP_EXPR
, TREE_TYPE (decl
),
316 TREE_OPERAND (cond
, 0));
319 if (decl
== TREE_OPERAND (cond
, 0))
321 else if (decl
== TREE_OPERAND (cond
, 1))
324 swap_tree_comparison (TREE_CODE (cond
)));
325 TREE_OPERAND (cond
, 1) = TREE_OPERAND (cond
, 0);
326 TREE_OPERAND (cond
, 0) = decl
;
330 if (TREE_CODE (cond
) == NE_EXPR
)
332 if (!INTEGRAL_TYPE_P (TREE_TYPE (decl
)))
334 else if (operand_equal_p (TREE_OPERAND (cond
, 1),
335 TYPE_MIN_VALUE (TREE_TYPE (decl
)),
337 TREE_SET_CODE (cond
, GT_EXPR
);
338 else if (operand_equal_p (TREE_OPERAND (cond
, 1),
339 TYPE_MAX_VALUE (TREE_TYPE (decl
)),
341 TREE_SET_CODE (cond
, LT_EXPR
);
349 error_at (elocus
, "invalid controlling predicate");
354 if (incr
== NULL_TREE
)
356 error_at (elocus
, "missing increment expression");
361 bool incr_ok
= false;
363 if (EXPR_HAS_LOCATION (incr
))
364 elocus
= EXPR_LOCATION (incr
);
366 /* Check all the valid increment expressions: v++, v--, ++v, --v,
367 v = v + incr, v = incr + v and v = v - incr. */
368 switch (TREE_CODE (incr
))
370 case POSTINCREMENT_EXPR
:
371 case PREINCREMENT_EXPR
:
372 case POSTDECREMENT_EXPR
:
373 case PREDECREMENT_EXPR
:
374 if (TREE_OPERAND (incr
, 0) != decl
)
378 if (POINTER_TYPE_P (TREE_TYPE (decl
))
379 && TREE_OPERAND (incr
, 1))
381 tree t
= fold_convert (sizetype
, TREE_OPERAND (incr
, 1));
383 if (TREE_CODE (incr
) == POSTDECREMENT_EXPR
384 || TREE_CODE (incr
) == PREDECREMENT_EXPR
)
385 t
= fold_build1 (NEGATE_EXPR
, sizetype
, t
);
386 t
= build2 (POINTER_PLUS_EXPR
, TREE_TYPE (decl
), decl
, t
);
387 incr
= build2 (MODIFY_EXPR
, void_type_node
, decl
, t
);
392 if (TREE_OPERAND (incr
, 0) != decl
)
394 if (TREE_OPERAND (incr
, 1) == decl
)
396 if (TREE_CODE (TREE_OPERAND (incr
, 1)) == PLUS_EXPR
397 && (TREE_OPERAND (TREE_OPERAND (incr
, 1), 0) == decl
398 || TREE_OPERAND (TREE_OPERAND (incr
, 1), 1) == decl
))
400 else if ((TREE_CODE (TREE_OPERAND (incr
, 1)) == MINUS_EXPR
401 || (TREE_CODE (TREE_OPERAND (incr
, 1))
402 == POINTER_PLUS_EXPR
))
403 && TREE_OPERAND (TREE_OPERAND (incr
, 1), 0) == decl
)
407 tree t
= check_omp_for_incr_expr (TREE_OPERAND (incr
, 1),
409 if (t
!= error_mark_node
)
412 t
= build2 (PLUS_EXPR
, TREE_TYPE (decl
), decl
, t
);
413 incr
= build2 (MODIFY_EXPR
, void_type_node
, decl
, t
);
423 error_at (elocus
, "invalid increment expression");
428 TREE_VEC_ELT (initv
, i
) = init
;
429 TREE_VEC_ELT (incrv
, i
) = incr
;
436 tree t
= make_node (OMP_FOR
);
438 TREE_TYPE (t
) = void_type_node
;
439 OMP_FOR_INIT (t
) = initv
;
440 OMP_FOR_COND (t
) = condv
;
441 OMP_FOR_INCR (t
) = incrv
;
442 OMP_FOR_BODY (t
) = body
;
443 OMP_FOR_PRE_BODY (t
) = pre_body
;
445 SET_EXPR_LOCATION (t
, locus
);
451 /* Divide CLAUSES into two lists: those that apply to a parallel construct,
452 and those that apply to a work-sharing construct. Place the results in
453 *PAR_CLAUSES and *WS_CLAUSES respectively. In addition, add a nowait
454 clause to the work-sharing list. */
457 c_split_parallel_clauses (tree clauses
, tree
*par_clauses
, tree
*ws_clauses
)
462 *ws_clauses
= build_omp_clause (OMP_CLAUSE_NOWAIT
);
464 for (; clauses
; clauses
= next
)
466 next
= OMP_CLAUSE_CHAIN (clauses
);
468 switch (OMP_CLAUSE_CODE (clauses
))
470 case OMP_CLAUSE_PRIVATE
:
471 case OMP_CLAUSE_SHARED
:
472 case OMP_CLAUSE_FIRSTPRIVATE
:
473 case OMP_CLAUSE_LASTPRIVATE
:
474 case OMP_CLAUSE_REDUCTION
:
475 case OMP_CLAUSE_COPYIN
:
477 case OMP_CLAUSE_NUM_THREADS
:
478 case OMP_CLAUSE_DEFAULT
:
479 OMP_CLAUSE_CHAIN (clauses
) = *par_clauses
;
480 *par_clauses
= clauses
;
483 case OMP_CLAUSE_SCHEDULE
:
484 case OMP_CLAUSE_ORDERED
:
485 case OMP_CLAUSE_COLLAPSE
:
486 OMP_CLAUSE_CHAIN (clauses
) = *ws_clauses
;
487 *ws_clauses
= clauses
;
496 /* True if OpenMP sharing attribute of DECL is predetermined. */
498 enum omp_clause_default_kind
499 c_omp_predetermined_sharing (tree decl
)
501 /* Variables with const-qualified type having no mutable member
502 are predetermined shared. */
503 if (TREE_READONLY (decl
))
504 return OMP_CLAUSE_DEFAULT_SHARED
;
506 return OMP_CLAUSE_DEFAULT_UNSPECIFIED
;