1 /* Lowering pass for OMP directives. Converts OMP directives into explicit
2 calls to the runtime library (libgomp), data marshalling to implement data
3 sharing and copying clauses, offloading to accelerators, and more.
5 Contributed by Diego Novillo <dnovillo@redhat.com>
7 Copyright (C) 2005-2018 Free Software Foundation, Inc.
9 This file is part of GCC.
11 GCC is free software; you can redistribute it and/or modify it under
12 the terms of the GNU General Public License as published by the Free
13 Software Foundation; either version 3, or (at your option) any later
16 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
17 WARRANTY; without even the implied warranty of MERCHANTABILITY or
18 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
21 You should have received a copy of the GNU General Public License
22 along with GCC; see the file COPYING3. If not see
23 <http://www.gnu.org/licenses/>. */
27 #include "coretypes.h"
32 #include "tree-pass.h"
35 #include "pretty-print.h"
36 #include "diagnostic-core.h"
37 #include "fold-const.h"
38 #include "stor-layout.h"
39 #include "internal-fn.h"
40 #include "gimple-fold.h"
42 #include "gimple-iterator.h"
43 #include "gimplify-me.h"
44 #include "gimple-walk.h"
45 #include "tree-iterator.h"
46 #include "tree-inline.h"
47 #include "langhooks.h"
50 #include "splay-tree.h"
51 #include "omp-general.h"
54 #include "gimple-low.h"
55 #include "symbol-summary.h"
56 #include "tree-nested.h"
58 #include "gomp-constants.h"
59 #include "gimple-pretty-print.h"
60 #include "hsa-common.h"
61 #include "stringpool.h"
64 /* Lowering of OMP parallel and workshare constructs proceeds in two
65 phases. The first phase scans the function looking for OMP statements
66 and then for variables that must be replaced to satisfy data sharing
67 clauses. The second phase expands code for the constructs, as well as
68 re-gimplifying things when variables have been replaced with complex
71 Final code generation is done by pass_expand_omp. The flowgraph is
72 scanned for regions which are then moved to a new
73 function, to be invoked by the thread library, or offloaded. */
75 /* Context structure. Used to store information about each parallel
76 directive in the code. */
80 /* This field must be at the beginning, as we do "inheritance": Some
81 callback functions for tree-inline.c (e.g., omp_copy_decl)
82 receive a copy_body_data pointer that is up-casted to an
83 omp_context pointer. */
86 /* The tree of contexts corresponding to the encountered constructs. */
87 struct omp_context
*outer
;
90 /* Map variables to fields in a structure that allows communication
91 between sending and receiving threads. */
97 /* These are used just by task contexts, if task firstprivate fn is
98 needed. srecord_type is used to communicate from the thread
99 that encountered the task construct to task firstprivate fn,
100 record_type is allocated by GOMP_task, initialized by task firstprivate
101 fn and passed to the task body fn. */
102 splay_tree sfield_map
;
105 /* A chain of variables to add to the top-level block surrounding the
106 construct. In the case of a parallel, this is in the child function. */
109 /* Label to which GOMP_cancel{,llation_point} and explicit and implicit
110 barriers should jump to during omplower pass. */
113 /* The sibling GIMPLE_OMP_FOR simd with _simt_ clause or NULL
117 /* Nesting depth of this context. Used to beautify error messages re
118 invalid gotos. The outermost ctx is depth 1, with depth 0 being
119 reserved for the main body of the function. */
122 /* True if this parallel directive is nested within another. */
125 /* True if this construct can be cancelled. */
129 static splay_tree all_contexts
;
130 static int taskreg_nesting_level
;
131 static int target_nesting_level
;
132 static bitmap task_shared_vars
;
133 static vec
<omp_context
*> taskreg_contexts
;
135 static void scan_omp (gimple_seq
*, omp_context
*);
136 static tree
scan_omp_1_op (tree
*, int *, void *);
138 #define WALK_SUBSTMTS \
142 case GIMPLE_EH_FILTER: \
143 case GIMPLE_TRANSACTION: \
144 /* The sub-statements for these should be walked. */ \
145 *handled_ops_p = false; \
148 /* Return true if CTX corresponds to an oacc parallel region. */
151 is_oacc_parallel (omp_context
*ctx
)
153 enum gimple_code outer_type
= gimple_code (ctx
->stmt
);
154 return ((outer_type
== GIMPLE_OMP_TARGET
)
155 && (gimple_omp_target_kind (ctx
->stmt
)
156 == GF_OMP_TARGET_KIND_OACC_PARALLEL
));
159 /* Return true if CTX corresponds to an oacc kernels region. */
162 is_oacc_kernels (omp_context
*ctx
)
164 enum gimple_code outer_type
= gimple_code (ctx
->stmt
);
165 return ((outer_type
== GIMPLE_OMP_TARGET
)
166 && (gimple_omp_target_kind (ctx
->stmt
)
167 == GF_OMP_TARGET_KIND_OACC_KERNELS
));
170 /* If DECL is the artificial dummy VAR_DECL created for non-static
171 data member privatization, return the underlying "this" parameter,
172 otherwise return NULL. */
175 omp_member_access_dummy_var (tree decl
)
178 || !DECL_ARTIFICIAL (decl
)
179 || !DECL_IGNORED_P (decl
)
180 || !DECL_HAS_VALUE_EXPR_P (decl
)
181 || !lang_hooks
.decls
.omp_disregard_value_expr (decl
, false))
184 tree v
= DECL_VALUE_EXPR (decl
);
185 if (TREE_CODE (v
) != COMPONENT_REF
)
189 switch (TREE_CODE (v
))
195 case POINTER_PLUS_EXPR
:
196 v
= TREE_OPERAND (v
, 0);
199 if (DECL_CONTEXT (v
) == current_function_decl
200 && DECL_ARTIFICIAL (v
)
201 && TREE_CODE (TREE_TYPE (v
)) == POINTER_TYPE
)
209 /* Helper for unshare_and_remap, called through walk_tree. */
212 unshare_and_remap_1 (tree
*tp
, int *walk_subtrees
, void *data
)
214 tree
*pair
= (tree
*) data
;
217 *tp
= unshare_expr (pair
[1]);
220 else if (IS_TYPE_OR_DECL_P (*tp
))
225 /* Return unshare_expr (X) with all occurrences of FROM
229 unshare_and_remap (tree x
, tree from
, tree to
)
231 tree pair
[2] = { from
, to
};
232 x
= unshare_expr (x
);
233 walk_tree (&x
, unshare_and_remap_1
, pair
, NULL
);
237 /* Convenience function for calling scan_omp_1_op on tree operands. */
240 scan_omp_op (tree
*tp
, omp_context
*ctx
)
242 struct walk_stmt_info wi
;
244 memset (&wi
, 0, sizeof (wi
));
246 wi
.want_locations
= true;
248 return walk_tree (tp
, scan_omp_1_op
, &wi
, NULL
);
251 static void lower_omp (gimple_seq
*, omp_context
*);
252 static tree
lookup_decl_in_outer_ctx (tree
, omp_context
*);
253 static tree
maybe_lookup_decl_in_outer_ctx (tree
, omp_context
*);
255 /* Return true if CTX is for an omp parallel. */
258 is_parallel_ctx (omp_context
*ctx
)
260 return gimple_code (ctx
->stmt
) == GIMPLE_OMP_PARALLEL
;
264 /* Return true if CTX is for an omp task. */
267 is_task_ctx (omp_context
*ctx
)
269 return gimple_code (ctx
->stmt
) == GIMPLE_OMP_TASK
;
273 /* Return true if CTX is for an omp taskloop. */
276 is_taskloop_ctx (omp_context
*ctx
)
278 return gimple_code (ctx
->stmt
) == GIMPLE_OMP_FOR
279 && gimple_omp_for_kind (ctx
->stmt
) == GF_OMP_FOR_KIND_TASKLOOP
;
283 /* Return true if CTX is for an omp parallel or omp task. */
286 is_taskreg_ctx (omp_context
*ctx
)
288 return is_parallel_ctx (ctx
) || is_task_ctx (ctx
);
291 /* Return true if EXPR is variable sized. */
294 is_variable_sized (const_tree expr
)
296 return !TREE_CONSTANT (TYPE_SIZE_UNIT (TREE_TYPE (expr
)));
299 /* Lookup variables. The "maybe" form
300 allows for the variable form to not have been entered, otherwise we
301 assert that the variable must have been entered. */
304 lookup_decl (tree var
, omp_context
*ctx
)
306 tree
*n
= ctx
->cb
.decl_map
->get (var
);
311 maybe_lookup_decl (const_tree var
, omp_context
*ctx
)
313 tree
*n
= ctx
->cb
.decl_map
->get (const_cast<tree
> (var
));
314 return n
? *n
: NULL_TREE
;
318 lookup_field (tree var
, omp_context
*ctx
)
321 n
= splay_tree_lookup (ctx
->field_map
, (splay_tree_key
) var
);
322 return (tree
) n
->value
;
326 lookup_sfield (splay_tree_key key
, omp_context
*ctx
)
329 n
= splay_tree_lookup (ctx
->sfield_map
330 ? ctx
->sfield_map
: ctx
->field_map
, key
);
331 return (tree
) n
->value
;
335 lookup_sfield (tree var
, omp_context
*ctx
)
337 return lookup_sfield ((splay_tree_key
) var
, ctx
);
341 maybe_lookup_field (splay_tree_key key
, omp_context
*ctx
)
344 n
= splay_tree_lookup (ctx
->field_map
, key
);
345 return n
? (tree
) n
->value
: NULL_TREE
;
349 maybe_lookup_field (tree var
, omp_context
*ctx
)
351 return maybe_lookup_field ((splay_tree_key
) var
, ctx
);
354 /* Return true if DECL should be copied by pointer. SHARED_CTX is
355 the parallel context if DECL is to be shared. */
358 use_pointer_for_field (tree decl
, omp_context
*shared_ctx
)
360 if (AGGREGATE_TYPE_P (TREE_TYPE (decl
))
361 || TYPE_ATOMIC (TREE_TYPE (decl
)))
364 /* We can only use copy-in/copy-out semantics for shared variables
365 when we know the value is not accessible from an outer scope. */
368 gcc_assert (!is_gimple_omp_oacc (shared_ctx
->stmt
));
370 /* ??? Trivially accessible from anywhere. But why would we even
371 be passing an address in this case? Should we simply assert
372 this to be false, or should we have a cleanup pass that removes
373 these from the list of mappings? */
374 if (TREE_STATIC (decl
) || DECL_EXTERNAL (decl
))
377 /* For variables with DECL_HAS_VALUE_EXPR_P set, we cannot tell
378 without analyzing the expression whether or not its location
379 is accessible to anyone else. In the case of nested parallel
380 regions it certainly may be. */
381 if (TREE_CODE (decl
) != RESULT_DECL
&& DECL_HAS_VALUE_EXPR_P (decl
))
384 /* Do not use copy-in/copy-out for variables that have their
386 if (TREE_ADDRESSABLE (decl
))
389 /* lower_send_shared_vars only uses copy-in, but not copy-out
391 if (TREE_READONLY (decl
)
392 || ((TREE_CODE (decl
) == RESULT_DECL
393 || TREE_CODE (decl
) == PARM_DECL
)
394 && DECL_BY_REFERENCE (decl
)))
397 /* Disallow copy-in/out in nested parallel if
398 decl is shared in outer parallel, otherwise
399 each thread could store the shared variable
400 in its own copy-in location, making the
401 variable no longer really shared. */
402 if (shared_ctx
->is_nested
)
406 for (up
= shared_ctx
->outer
; up
; up
= up
->outer
)
407 if (is_taskreg_ctx (up
) && maybe_lookup_decl (decl
, up
))
414 for (c
= gimple_omp_taskreg_clauses (up
->stmt
);
415 c
; c
= OMP_CLAUSE_CHAIN (c
))
416 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_SHARED
417 && OMP_CLAUSE_DECL (c
) == decl
)
421 goto maybe_mark_addressable_and_ret
;
425 /* For tasks avoid using copy-in/out. As tasks can be
426 deferred or executed in different thread, when GOMP_task
427 returns, the task hasn't necessarily terminated. */
428 if (is_task_ctx (shared_ctx
))
431 maybe_mark_addressable_and_ret
:
432 outer
= maybe_lookup_decl_in_outer_ctx (decl
, shared_ctx
);
433 if (is_gimple_reg (outer
) && !omp_member_access_dummy_var (outer
))
435 /* Taking address of OUTER in lower_send_shared_vars
436 might need regimplification of everything that uses the
438 if (!task_shared_vars
)
439 task_shared_vars
= BITMAP_ALLOC (NULL
);
440 bitmap_set_bit (task_shared_vars
, DECL_UID (outer
));
441 TREE_ADDRESSABLE (outer
) = 1;
450 /* Construct a new automatic decl similar to VAR. */
453 omp_copy_decl_2 (tree var
, tree name
, tree type
, omp_context
*ctx
)
455 tree copy
= copy_var_decl (var
, name
, type
);
457 DECL_CONTEXT (copy
) = current_function_decl
;
458 DECL_CHAIN (copy
) = ctx
->block_vars
;
459 /* If VAR is listed in task_shared_vars, it means it wasn't
460 originally addressable and is just because task needs to take
461 it's address. But we don't need to take address of privatizations
463 if (TREE_ADDRESSABLE (var
)
465 && bitmap_bit_p (task_shared_vars
, DECL_UID (var
)))
466 TREE_ADDRESSABLE (copy
) = 0;
467 ctx
->block_vars
= copy
;
473 omp_copy_decl_1 (tree var
, omp_context
*ctx
)
475 return omp_copy_decl_2 (var
, DECL_NAME (var
), TREE_TYPE (var
), ctx
);
478 /* Build COMPONENT_REF and set TREE_THIS_VOLATILE and TREE_READONLY on it
481 omp_build_component_ref (tree obj
, tree field
)
483 tree ret
= build3 (COMPONENT_REF
, TREE_TYPE (field
), obj
, field
, NULL
);
484 if (TREE_THIS_VOLATILE (field
))
485 TREE_THIS_VOLATILE (ret
) |= 1;
486 if (TREE_READONLY (field
))
487 TREE_READONLY (ret
) |= 1;
491 /* Build tree nodes to access the field for VAR on the receiver side. */
494 build_receiver_ref (tree var
, bool by_ref
, omp_context
*ctx
)
496 tree x
, field
= lookup_field (var
, ctx
);
498 /* If the receiver record type was remapped in the child function,
499 remap the field into the new record type. */
500 x
= maybe_lookup_field (field
, ctx
);
504 x
= build_simple_mem_ref (ctx
->receiver_decl
);
505 TREE_THIS_NOTRAP (x
) = 1;
506 x
= omp_build_component_ref (x
, field
);
509 x
= build_simple_mem_ref (x
);
510 TREE_THIS_NOTRAP (x
) = 1;
516 /* Build tree nodes to access VAR in the scope outer to CTX. In the case
517 of a parallel, this is a component reference; for workshare constructs
518 this is some variable. */
521 build_outer_var_ref (tree var
, omp_context
*ctx
,
522 enum omp_clause_code code
= OMP_CLAUSE_ERROR
)
526 if (is_global_var (maybe_lookup_decl_in_outer_ctx (var
, ctx
)))
528 else if (is_variable_sized (var
))
530 x
= TREE_OPERAND (DECL_VALUE_EXPR (var
), 0);
531 x
= build_outer_var_ref (x
, ctx
, code
);
532 x
= build_simple_mem_ref (x
);
534 else if (is_taskreg_ctx (ctx
))
536 bool by_ref
= use_pointer_for_field (var
, NULL
);
537 x
= build_receiver_ref (var
, by_ref
, ctx
);
539 else if ((gimple_code (ctx
->stmt
) == GIMPLE_OMP_FOR
540 && gimple_omp_for_kind (ctx
->stmt
) & GF_OMP_FOR_SIMD
)
541 || (code
== OMP_CLAUSE_PRIVATE
542 && (gimple_code (ctx
->stmt
) == GIMPLE_OMP_FOR
543 || gimple_code (ctx
->stmt
) == GIMPLE_OMP_SECTIONS
544 || gimple_code (ctx
->stmt
) == GIMPLE_OMP_SINGLE
)))
546 /* #pragma omp simd isn't a worksharing construct, and can reference
547 even private vars in its linear etc. clauses.
548 Similarly for OMP_CLAUSE_PRIVATE with outer ref, that can refer
549 to private vars in all worksharing constructs. */
551 if (ctx
->outer
&& is_taskreg_ctx (ctx
))
552 x
= lookup_decl (var
, ctx
->outer
);
554 x
= maybe_lookup_decl_in_outer_ctx (var
, ctx
);
558 else if (code
== OMP_CLAUSE_LASTPRIVATE
&& is_taskloop_ctx (ctx
))
560 gcc_assert (ctx
->outer
);
562 = splay_tree_lookup (ctx
->outer
->field_map
,
563 (splay_tree_key
) &DECL_UID (var
));
566 if (is_global_var (maybe_lookup_decl_in_outer_ctx (var
, ctx
->outer
)))
569 x
= lookup_decl (var
, ctx
->outer
);
573 tree field
= (tree
) n
->value
;
574 /* If the receiver record type was remapped in the child function,
575 remap the field into the new record type. */
576 x
= maybe_lookup_field (field
, ctx
->outer
);
580 x
= build_simple_mem_ref (ctx
->outer
->receiver_decl
);
581 x
= omp_build_component_ref (x
, field
);
582 if (use_pointer_for_field (var
, ctx
->outer
))
583 x
= build_simple_mem_ref (x
);
588 omp_context
*outer
= ctx
->outer
;
589 if (gimple_code (outer
->stmt
) == GIMPLE_OMP_GRID_BODY
)
591 outer
= outer
->outer
;
593 && gimple_code (outer
->stmt
) != GIMPLE_OMP_GRID_BODY
);
595 x
= lookup_decl (var
, outer
);
597 else if (omp_is_reference (var
))
598 /* This can happen with orphaned constructs. If var is reference, it is
599 possible it is shared and as such valid. */
601 else if (omp_member_access_dummy_var (var
))
608 tree t
= omp_member_access_dummy_var (var
);
611 x
= DECL_VALUE_EXPR (var
);
612 tree o
= maybe_lookup_decl_in_outer_ctx (t
, ctx
);
614 x
= unshare_and_remap (x
, t
, o
);
616 x
= unshare_expr (x
);
620 if (omp_is_reference (var
))
621 x
= build_simple_mem_ref (x
);
626 /* Build tree nodes to access the field for VAR on the sender side. */
629 build_sender_ref (splay_tree_key key
, omp_context
*ctx
)
631 tree field
= lookup_sfield (key
, ctx
);
632 return omp_build_component_ref (ctx
->sender_decl
, field
);
636 build_sender_ref (tree var
, omp_context
*ctx
)
638 return build_sender_ref ((splay_tree_key
) var
, ctx
);
641 /* Add a new field for VAR inside the structure CTX->SENDER_DECL. If
642 BASE_POINTERS_RESTRICT, declare the field with restrict. */
645 install_var_field (tree var
, bool by_ref
, int mask
, omp_context
*ctx
)
647 tree field
, type
, sfield
= NULL_TREE
;
648 splay_tree_key key
= (splay_tree_key
) var
;
652 key
= (splay_tree_key
) &DECL_UID (var
);
653 gcc_checking_assert (key
!= (splay_tree_key
) var
);
655 gcc_assert ((mask
& 1) == 0
656 || !splay_tree_lookup (ctx
->field_map
, key
));
657 gcc_assert ((mask
& 2) == 0 || !ctx
->sfield_map
658 || !splay_tree_lookup (ctx
->sfield_map
, key
));
659 gcc_assert ((mask
& 3) == 3
660 || !is_gimple_omp_oacc (ctx
->stmt
));
662 type
= TREE_TYPE (var
);
663 /* Prevent redeclaring the var in the split-off function with a restrict
664 pointer type. Note that we only clear type itself, restrict qualifiers in
665 the pointed-to type will be ignored by points-to analysis. */
666 if (POINTER_TYPE_P (type
)
667 && TYPE_RESTRICT (type
))
668 type
= build_qualified_type (type
, TYPE_QUALS (type
) & ~TYPE_QUAL_RESTRICT
);
672 gcc_assert (TREE_CODE (type
) == ARRAY_TYPE
);
673 type
= build_pointer_type (build_pointer_type (type
));
676 type
= build_pointer_type (type
);
677 else if ((mask
& 3) == 1 && omp_is_reference (var
))
678 type
= TREE_TYPE (type
);
680 field
= build_decl (DECL_SOURCE_LOCATION (var
),
681 FIELD_DECL
, DECL_NAME (var
), type
);
683 /* Remember what variable this field was created for. This does have a
684 side effect of making dwarf2out ignore this member, so for helpful
685 debugging we clear it later in delete_omp_context. */
686 DECL_ABSTRACT_ORIGIN (field
) = var
;
687 if (type
== TREE_TYPE (var
))
689 SET_DECL_ALIGN (field
, DECL_ALIGN (var
));
690 DECL_USER_ALIGN (field
) = DECL_USER_ALIGN (var
);
691 TREE_THIS_VOLATILE (field
) = TREE_THIS_VOLATILE (var
);
694 SET_DECL_ALIGN (field
, TYPE_ALIGN (type
));
698 insert_field_into_struct (ctx
->record_type
, field
);
699 if (ctx
->srecord_type
)
701 sfield
= build_decl (DECL_SOURCE_LOCATION (var
),
702 FIELD_DECL
, DECL_NAME (var
), type
);
703 DECL_ABSTRACT_ORIGIN (sfield
) = var
;
704 SET_DECL_ALIGN (sfield
, DECL_ALIGN (field
));
705 DECL_USER_ALIGN (sfield
) = DECL_USER_ALIGN (field
);
706 TREE_THIS_VOLATILE (sfield
) = TREE_THIS_VOLATILE (field
);
707 insert_field_into_struct (ctx
->srecord_type
, sfield
);
712 if (ctx
->srecord_type
== NULL_TREE
)
716 ctx
->srecord_type
= lang_hooks
.types
.make_type (RECORD_TYPE
);
717 ctx
->sfield_map
= splay_tree_new (splay_tree_compare_pointers
, 0, 0);
718 for (t
= TYPE_FIELDS (ctx
->record_type
); t
; t
= TREE_CHAIN (t
))
720 sfield
= build_decl (DECL_SOURCE_LOCATION (t
),
721 FIELD_DECL
, DECL_NAME (t
), TREE_TYPE (t
));
722 DECL_ABSTRACT_ORIGIN (sfield
) = DECL_ABSTRACT_ORIGIN (t
);
723 insert_field_into_struct (ctx
->srecord_type
, sfield
);
724 splay_tree_insert (ctx
->sfield_map
,
725 (splay_tree_key
) DECL_ABSTRACT_ORIGIN (t
),
726 (splay_tree_value
) sfield
);
730 insert_field_into_struct ((mask
& 1) ? ctx
->record_type
731 : ctx
->srecord_type
, field
);
735 splay_tree_insert (ctx
->field_map
, key
, (splay_tree_value
) field
);
736 if ((mask
& 2) && ctx
->sfield_map
)
737 splay_tree_insert (ctx
->sfield_map
, key
, (splay_tree_value
) sfield
);
741 install_var_local (tree var
, omp_context
*ctx
)
743 tree new_var
= omp_copy_decl_1 (var
, ctx
);
744 insert_decl_map (&ctx
->cb
, var
, new_var
);
748 /* Adjust the replacement for DECL in CTX for the new context. This means
749 copying the DECL_VALUE_EXPR, and fixing up the type. */
752 fixup_remapped_decl (tree decl
, omp_context
*ctx
, bool private_debug
)
756 new_decl
= lookup_decl (decl
, ctx
);
758 TREE_TYPE (new_decl
) = remap_type (TREE_TYPE (decl
), &ctx
->cb
);
760 if ((!TREE_CONSTANT (DECL_SIZE (new_decl
)) || private_debug
)
761 && DECL_HAS_VALUE_EXPR_P (decl
))
763 tree ve
= DECL_VALUE_EXPR (decl
);
764 walk_tree (&ve
, copy_tree_body_r
, &ctx
->cb
, NULL
);
765 SET_DECL_VALUE_EXPR (new_decl
, ve
);
766 DECL_HAS_VALUE_EXPR_P (new_decl
) = 1;
769 if (!TREE_CONSTANT (DECL_SIZE (new_decl
)))
771 size
= remap_decl (DECL_SIZE (decl
), &ctx
->cb
);
772 if (size
== error_mark_node
)
773 size
= TYPE_SIZE (TREE_TYPE (new_decl
));
774 DECL_SIZE (new_decl
) = size
;
776 size
= remap_decl (DECL_SIZE_UNIT (decl
), &ctx
->cb
);
777 if (size
== error_mark_node
)
778 size
= TYPE_SIZE_UNIT (TREE_TYPE (new_decl
));
779 DECL_SIZE_UNIT (new_decl
) = size
;
783 /* The callback for remap_decl. Search all containing contexts for a
784 mapping of the variable; this avoids having to duplicate the splay
785 tree ahead of time. We know a mapping doesn't already exist in the
786 given context. Create new mappings to implement default semantics. */
789 omp_copy_decl (tree var
, copy_body_data
*cb
)
791 omp_context
*ctx
= (omp_context
*) cb
;
794 if (TREE_CODE (var
) == LABEL_DECL
)
796 if (FORCED_LABEL (var
) || DECL_NONLOCAL (var
))
798 new_var
= create_artificial_label (DECL_SOURCE_LOCATION (var
));
799 DECL_CONTEXT (new_var
) = current_function_decl
;
800 insert_decl_map (&ctx
->cb
, var
, new_var
);
804 while (!is_taskreg_ctx (ctx
))
809 new_var
= maybe_lookup_decl (var
, ctx
);
814 if (is_global_var (var
) || decl_function_context (var
) != ctx
->cb
.src_fn
)
817 return error_mark_node
;
820 /* Create a new context, with OUTER_CTX being the surrounding context. */
823 new_omp_context (gimple
*stmt
, omp_context
*outer_ctx
)
825 omp_context
*ctx
= XCNEW (omp_context
);
827 splay_tree_insert (all_contexts
, (splay_tree_key
) stmt
,
828 (splay_tree_value
) ctx
);
833 ctx
->outer
= outer_ctx
;
834 ctx
->cb
= outer_ctx
->cb
;
835 ctx
->cb
.block
= NULL
;
836 ctx
->depth
= outer_ctx
->depth
+ 1;
840 ctx
->cb
.src_fn
= current_function_decl
;
841 ctx
->cb
.dst_fn
= current_function_decl
;
842 ctx
->cb
.src_node
= cgraph_node::get (current_function_decl
);
843 gcc_checking_assert (ctx
->cb
.src_node
);
844 ctx
->cb
.dst_node
= ctx
->cb
.src_node
;
845 ctx
->cb
.src_cfun
= cfun
;
846 ctx
->cb
.copy_decl
= omp_copy_decl
;
847 ctx
->cb
.eh_lp_nr
= 0;
848 ctx
->cb
.transform_call_graph_edges
= CB_CGE_MOVE
;
852 ctx
->cb
.decl_map
= new hash_map
<tree
, tree
>;
857 static gimple_seq
maybe_catch_exception (gimple_seq
);
859 /* Finalize task copyfn. */
862 finalize_task_copyfn (gomp_task
*task_stmt
)
864 struct function
*child_cfun
;
866 gimple_seq seq
= NULL
, new_seq
;
869 child_fn
= gimple_omp_task_copy_fn (task_stmt
);
870 if (child_fn
== NULL_TREE
)
873 child_cfun
= DECL_STRUCT_FUNCTION (child_fn
);
874 DECL_STRUCT_FUNCTION (child_fn
)->curr_properties
= cfun
->curr_properties
;
876 push_cfun (child_cfun
);
877 bind
= gimplify_body (child_fn
, false);
878 gimple_seq_add_stmt (&seq
, bind
);
879 new_seq
= maybe_catch_exception (seq
);
882 bind
= gimple_build_bind (NULL
, new_seq
, NULL
);
884 gimple_seq_add_stmt (&seq
, bind
);
886 gimple_set_body (child_fn
, seq
);
889 /* Inform the callgraph about the new function. */
890 cgraph_node
*node
= cgraph_node::get_create (child_fn
);
891 node
->parallelized_function
= 1;
892 cgraph_node::add_new_function (child_fn
, false);
895 /* Destroy a omp_context data structures. Called through the splay tree
896 value delete callback. */
899 delete_omp_context (splay_tree_value value
)
901 omp_context
*ctx
= (omp_context
*) value
;
903 delete ctx
->cb
.decl_map
;
906 splay_tree_delete (ctx
->field_map
);
908 splay_tree_delete (ctx
->sfield_map
);
910 /* We hijacked DECL_ABSTRACT_ORIGIN earlier. We need to clear it before
911 it produces corrupt debug information. */
912 if (ctx
->record_type
)
915 for (t
= TYPE_FIELDS (ctx
->record_type
); t
; t
= DECL_CHAIN (t
))
916 DECL_ABSTRACT_ORIGIN (t
) = NULL
;
918 if (ctx
->srecord_type
)
921 for (t
= TYPE_FIELDS (ctx
->srecord_type
); t
; t
= DECL_CHAIN (t
))
922 DECL_ABSTRACT_ORIGIN (t
) = NULL
;
925 if (is_task_ctx (ctx
))
926 finalize_task_copyfn (as_a
<gomp_task
*> (ctx
->stmt
));
931 /* Fix up RECEIVER_DECL with a type that has been remapped to the child
935 fixup_child_record_type (omp_context
*ctx
)
937 tree f
, type
= ctx
->record_type
;
939 if (!ctx
->receiver_decl
)
941 /* ??? It isn't sufficient to just call remap_type here, because
942 variably_modified_type_p doesn't work the way we expect for
943 record types. Testing each field for whether it needs remapping
944 and creating a new record by hand works, however. */
945 for (f
= TYPE_FIELDS (type
); f
; f
= DECL_CHAIN (f
))
946 if (variably_modified_type_p (TREE_TYPE (f
), ctx
->cb
.src_fn
))
950 tree name
, new_fields
= NULL
;
952 type
= lang_hooks
.types
.make_type (RECORD_TYPE
);
953 name
= DECL_NAME (TYPE_NAME (ctx
->record_type
));
954 name
= build_decl (DECL_SOURCE_LOCATION (ctx
->receiver_decl
),
955 TYPE_DECL
, name
, type
);
956 TYPE_NAME (type
) = name
;
958 for (f
= TYPE_FIELDS (ctx
->record_type
); f
; f
= DECL_CHAIN (f
))
960 tree new_f
= copy_node (f
);
961 DECL_CONTEXT (new_f
) = type
;
962 TREE_TYPE (new_f
) = remap_type (TREE_TYPE (f
), &ctx
->cb
);
963 DECL_CHAIN (new_f
) = new_fields
;
964 walk_tree (&DECL_SIZE (new_f
), copy_tree_body_r
, &ctx
->cb
, NULL
);
965 walk_tree (&DECL_SIZE_UNIT (new_f
), copy_tree_body_r
,
967 walk_tree (&DECL_FIELD_OFFSET (new_f
), copy_tree_body_r
,
971 /* Arrange to be able to look up the receiver field
972 given the sender field. */
973 splay_tree_insert (ctx
->field_map
, (splay_tree_key
) f
,
974 (splay_tree_value
) new_f
);
976 TYPE_FIELDS (type
) = nreverse (new_fields
);
980 /* In a target region we never modify any of the pointers in *.omp_data_i,
981 so attempt to help the optimizers. */
982 if (is_gimple_omp_offloaded (ctx
->stmt
))
983 type
= build_qualified_type (type
, TYPE_QUAL_CONST
);
985 TREE_TYPE (ctx
->receiver_decl
)
986 = build_qualified_type (build_reference_type (type
), TYPE_QUAL_RESTRICT
);
989 /* Instantiate decls as necessary in CTX to satisfy the data sharing
990 specified by CLAUSES. */
993 scan_sharing_clauses (tree clauses
, omp_context
*ctx
)
996 bool scan_array_reductions
= false;
998 for (c
= clauses
; c
; c
= OMP_CLAUSE_CHAIN (c
))
1002 switch (OMP_CLAUSE_CODE (c
))
1004 case OMP_CLAUSE_PRIVATE
:
1005 decl
= OMP_CLAUSE_DECL (c
);
1006 if (OMP_CLAUSE_PRIVATE_OUTER_REF (c
))
1008 else if (!is_variable_sized (decl
))
1009 install_var_local (decl
, ctx
);
1012 case OMP_CLAUSE_SHARED
:
1013 decl
= OMP_CLAUSE_DECL (c
);
1014 /* Ignore shared directives in teams construct. */
1015 if (gimple_code (ctx
->stmt
) == GIMPLE_OMP_TEAMS
)
1017 /* Global variables don't need to be copied,
1018 the receiver side will use them directly. */
1019 tree odecl
= maybe_lookup_decl_in_outer_ctx (decl
, ctx
);
1020 if (is_global_var (odecl
))
1022 insert_decl_map (&ctx
->cb
, decl
, odecl
);
1025 gcc_assert (is_taskreg_ctx (ctx
));
1026 gcc_assert (!COMPLETE_TYPE_P (TREE_TYPE (decl
))
1027 || !is_variable_sized (decl
));
1028 /* Global variables don't need to be copied,
1029 the receiver side will use them directly. */
1030 if (is_global_var (maybe_lookup_decl_in_outer_ctx (decl
, ctx
)))
1032 if (OMP_CLAUSE_SHARED_FIRSTPRIVATE (c
))
1034 use_pointer_for_field (decl
, ctx
);
1037 by_ref
= use_pointer_for_field (decl
, NULL
);
1038 if ((! TREE_READONLY (decl
) && !OMP_CLAUSE_SHARED_READONLY (c
))
1039 || TREE_ADDRESSABLE (decl
)
1041 || omp_is_reference (decl
))
1043 by_ref
= use_pointer_for_field (decl
, ctx
);
1044 install_var_field (decl
, by_ref
, 3, ctx
);
1045 install_var_local (decl
, ctx
);
1048 /* We don't need to copy const scalar vars back. */
1049 OMP_CLAUSE_SET_CODE (c
, OMP_CLAUSE_FIRSTPRIVATE
);
1052 case OMP_CLAUSE_REDUCTION
:
1053 decl
= OMP_CLAUSE_DECL (c
);
1054 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_REDUCTION
1055 && TREE_CODE (decl
) == MEM_REF
)
1057 tree t
= TREE_OPERAND (decl
, 0);
1058 if (TREE_CODE (t
) == POINTER_PLUS_EXPR
)
1059 t
= TREE_OPERAND (t
, 0);
1060 if (TREE_CODE (t
) == INDIRECT_REF
1061 || TREE_CODE (t
) == ADDR_EXPR
)
1062 t
= TREE_OPERAND (t
, 0);
1063 install_var_local (t
, ctx
);
1064 if (is_taskreg_ctx (ctx
)
1065 && !is_global_var (maybe_lookup_decl_in_outer_ctx (t
, ctx
))
1066 && !is_variable_sized (t
))
1068 by_ref
= use_pointer_for_field (t
, ctx
);
1069 install_var_field (t
, by_ref
, 3, ctx
);
1075 case OMP_CLAUSE_LASTPRIVATE
:
1076 /* Let the corresponding firstprivate clause create
1078 if (OMP_CLAUSE_LASTPRIVATE_FIRSTPRIVATE (c
))
1082 case OMP_CLAUSE_FIRSTPRIVATE
:
1083 case OMP_CLAUSE_LINEAR
:
1084 decl
= OMP_CLAUSE_DECL (c
);
1086 if ((OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_FIRSTPRIVATE
1087 || OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_IS_DEVICE_PTR
)
1088 && is_gimple_omp_offloaded (ctx
->stmt
))
1090 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_FIRSTPRIVATE
)
1091 install_var_field (decl
, !omp_is_reference (decl
), 3, ctx
);
1092 else if (TREE_CODE (TREE_TYPE (decl
)) == ARRAY_TYPE
)
1093 install_var_field (decl
, true, 3, ctx
);
1095 install_var_field (decl
, false, 3, ctx
);
1097 if (is_variable_sized (decl
))
1099 if (is_task_ctx (ctx
))
1100 install_var_field (decl
, false, 1, ctx
);
1103 else if (is_taskreg_ctx (ctx
))
1106 = is_global_var (maybe_lookup_decl_in_outer_ctx (decl
, ctx
));
1107 by_ref
= use_pointer_for_field (decl
, NULL
);
1109 if (is_task_ctx (ctx
)
1110 && (global
|| by_ref
|| omp_is_reference (decl
)))
1112 install_var_field (decl
, false, 1, ctx
);
1114 install_var_field (decl
, by_ref
, 2, ctx
);
1117 install_var_field (decl
, by_ref
, 3, ctx
);
1119 install_var_local (decl
, ctx
);
1122 case OMP_CLAUSE_USE_DEVICE_PTR
:
1123 decl
= OMP_CLAUSE_DECL (c
);
1124 if (TREE_CODE (TREE_TYPE (decl
)) == ARRAY_TYPE
)
1125 install_var_field (decl
, true, 3, ctx
);
1127 install_var_field (decl
, false, 3, ctx
);
1128 if (DECL_SIZE (decl
)
1129 && TREE_CODE (DECL_SIZE (decl
)) != INTEGER_CST
)
1131 tree decl2
= DECL_VALUE_EXPR (decl
);
1132 gcc_assert (TREE_CODE (decl2
) == INDIRECT_REF
);
1133 decl2
= TREE_OPERAND (decl2
, 0);
1134 gcc_assert (DECL_P (decl2
));
1135 install_var_local (decl2
, ctx
);
1137 install_var_local (decl
, ctx
);
1140 case OMP_CLAUSE_IS_DEVICE_PTR
:
1141 decl
= OMP_CLAUSE_DECL (c
);
1144 case OMP_CLAUSE__LOOPTEMP_
:
1145 gcc_assert (is_taskreg_ctx (ctx
));
1146 decl
= OMP_CLAUSE_DECL (c
);
1147 install_var_field (decl
, false, 3, ctx
);
1148 install_var_local (decl
, ctx
);
1151 case OMP_CLAUSE_COPYPRIVATE
:
1152 case OMP_CLAUSE_COPYIN
:
1153 decl
= OMP_CLAUSE_DECL (c
);
1154 by_ref
= use_pointer_for_field (decl
, NULL
);
1155 install_var_field (decl
, by_ref
, 3, ctx
);
1158 case OMP_CLAUSE_FINAL
:
1160 case OMP_CLAUSE_NUM_THREADS
:
1161 case OMP_CLAUSE_NUM_TEAMS
:
1162 case OMP_CLAUSE_THREAD_LIMIT
:
1163 case OMP_CLAUSE_DEVICE
:
1164 case OMP_CLAUSE_SCHEDULE
:
1165 case OMP_CLAUSE_DIST_SCHEDULE
:
1166 case OMP_CLAUSE_DEPEND
:
1167 case OMP_CLAUSE_PRIORITY
:
1168 case OMP_CLAUSE_GRAINSIZE
:
1169 case OMP_CLAUSE_NUM_TASKS
:
1170 case OMP_CLAUSE_NUM_GANGS
:
1171 case OMP_CLAUSE_NUM_WORKERS
:
1172 case OMP_CLAUSE_VECTOR_LENGTH
:
1174 scan_omp_op (&OMP_CLAUSE_OPERAND (c
, 0), ctx
->outer
);
1178 case OMP_CLAUSE_FROM
:
1179 case OMP_CLAUSE_MAP
:
1181 scan_omp_op (&OMP_CLAUSE_SIZE (c
), ctx
->outer
);
1182 decl
= OMP_CLAUSE_DECL (c
);
1183 /* Global variables with "omp declare target" attribute
1184 don't need to be copied, the receiver side will use them
1185 directly. However, global variables with "omp declare target link"
1186 attribute need to be copied. Or when ALWAYS modifier is used. */
1187 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_MAP
1189 && ((OMP_CLAUSE_MAP_KIND (c
) != GOMP_MAP_FIRSTPRIVATE_POINTER
1190 && (OMP_CLAUSE_MAP_KIND (c
)
1191 != GOMP_MAP_FIRSTPRIVATE_REFERENCE
))
1192 || TREE_CODE (TREE_TYPE (decl
)) == ARRAY_TYPE
)
1193 && OMP_CLAUSE_MAP_KIND (c
) != GOMP_MAP_ALWAYS_TO
1194 && OMP_CLAUSE_MAP_KIND (c
) != GOMP_MAP_ALWAYS_FROM
1195 && OMP_CLAUSE_MAP_KIND (c
) != GOMP_MAP_ALWAYS_TOFROM
1196 && is_global_var (maybe_lookup_decl_in_outer_ctx (decl
, ctx
))
1197 && varpool_node::get_create (decl
)->offloadable
1198 && !lookup_attribute ("omp declare target link",
1199 DECL_ATTRIBUTES (decl
)))
1201 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_MAP
1202 && OMP_CLAUSE_MAP_KIND (c
) == GOMP_MAP_POINTER
)
1204 /* Ignore GOMP_MAP_POINTER kind for arrays in regions that are
1205 not offloaded; there is nothing to map for those. */
1206 if (!is_gimple_omp_offloaded (ctx
->stmt
)
1207 && !POINTER_TYPE_P (TREE_TYPE (decl
))
1208 && !OMP_CLAUSE_MAP_ZERO_BIAS_ARRAY_SECTION (c
))
1211 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_MAP
1212 && (OMP_CLAUSE_MAP_KIND (c
) == GOMP_MAP_FIRSTPRIVATE_POINTER
1213 || (OMP_CLAUSE_MAP_KIND (c
)
1214 == GOMP_MAP_FIRSTPRIVATE_REFERENCE
)))
1216 if (TREE_CODE (decl
) == COMPONENT_REF
1217 || (TREE_CODE (decl
) == INDIRECT_REF
1218 && TREE_CODE (TREE_OPERAND (decl
, 0)) == COMPONENT_REF
1219 && (TREE_CODE (TREE_TYPE (TREE_OPERAND (decl
, 0)))
1220 == REFERENCE_TYPE
)))
1222 if (DECL_SIZE (decl
)
1223 && TREE_CODE (DECL_SIZE (decl
)) != INTEGER_CST
)
1225 tree decl2
= DECL_VALUE_EXPR (decl
);
1226 gcc_assert (TREE_CODE (decl2
) == INDIRECT_REF
);
1227 decl2
= TREE_OPERAND (decl2
, 0);
1228 gcc_assert (DECL_P (decl2
));
1229 install_var_local (decl2
, ctx
);
1231 install_var_local (decl
, ctx
);
1236 if (DECL_SIZE (decl
)
1237 && TREE_CODE (DECL_SIZE (decl
)) != INTEGER_CST
)
1239 tree decl2
= DECL_VALUE_EXPR (decl
);
1240 gcc_assert (TREE_CODE (decl2
) == INDIRECT_REF
);
1241 decl2
= TREE_OPERAND (decl2
, 0);
1242 gcc_assert (DECL_P (decl2
));
1243 install_var_field (decl2
, true, 3, ctx
);
1244 install_var_local (decl2
, ctx
);
1245 install_var_local (decl
, ctx
);
1249 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_MAP
1250 && OMP_CLAUSE_MAP_KIND (c
) == GOMP_MAP_POINTER
1251 && !OMP_CLAUSE_MAP_ZERO_BIAS_ARRAY_SECTION (c
)
1252 && TREE_CODE (TREE_TYPE (decl
)) == ARRAY_TYPE
)
1253 install_var_field (decl
, true, 7, ctx
);
1255 install_var_field (decl
, true, 3, ctx
);
1256 if (is_gimple_omp_offloaded (ctx
->stmt
)
1257 && !OMP_CLAUSE_MAP_IN_REDUCTION (c
))
1258 install_var_local (decl
, ctx
);
1263 tree base
= get_base_address (decl
);
1264 tree nc
= OMP_CLAUSE_CHAIN (c
);
1267 && OMP_CLAUSE_CODE (nc
) == OMP_CLAUSE_MAP
1268 && OMP_CLAUSE_DECL (nc
) == base
1269 && OMP_CLAUSE_MAP_KIND (nc
) == GOMP_MAP_POINTER
1270 && integer_zerop (OMP_CLAUSE_SIZE (nc
)))
1272 OMP_CLAUSE_MAP_ZERO_BIAS_ARRAY_SECTION (c
) = 1;
1273 OMP_CLAUSE_MAP_ZERO_BIAS_ARRAY_SECTION (nc
) = 1;
1279 scan_omp_op (&OMP_CLAUSE_DECL (c
), ctx
->outer
);
1280 decl
= OMP_CLAUSE_DECL (c
);
1282 gcc_assert (!splay_tree_lookup (ctx
->field_map
,
1283 (splay_tree_key
) decl
));
1285 = build_decl (OMP_CLAUSE_LOCATION (c
),
1286 FIELD_DECL
, NULL_TREE
, ptr_type_node
);
1287 SET_DECL_ALIGN (field
, TYPE_ALIGN (ptr_type_node
));
1288 insert_field_into_struct (ctx
->record_type
, field
);
1289 splay_tree_insert (ctx
->field_map
, (splay_tree_key
) decl
,
1290 (splay_tree_value
) field
);
1295 case OMP_CLAUSE__GRIDDIM_
:
1298 scan_omp_op (&OMP_CLAUSE__GRIDDIM__SIZE (c
), ctx
->outer
);
1299 scan_omp_op (&OMP_CLAUSE__GRIDDIM__GROUP (c
), ctx
->outer
);
1303 case OMP_CLAUSE_NOWAIT
:
1304 case OMP_CLAUSE_ORDERED
:
1305 case OMP_CLAUSE_COLLAPSE
:
1306 case OMP_CLAUSE_UNTIED
:
1307 case OMP_CLAUSE_MERGEABLE
:
1308 case OMP_CLAUSE_PROC_BIND
:
1309 case OMP_CLAUSE_SAFELEN
:
1310 case OMP_CLAUSE_SIMDLEN
:
1311 case OMP_CLAUSE_THREADS
:
1312 case OMP_CLAUSE_SIMD
:
1313 case OMP_CLAUSE_NOGROUP
:
1314 case OMP_CLAUSE_DEFAULTMAP
:
1315 case OMP_CLAUSE_ASYNC
:
1316 case OMP_CLAUSE_WAIT
:
1317 case OMP_CLAUSE_GANG
:
1318 case OMP_CLAUSE_WORKER
:
1319 case OMP_CLAUSE_VECTOR
:
1320 case OMP_CLAUSE_INDEPENDENT
:
1321 case OMP_CLAUSE_AUTO
:
1322 case OMP_CLAUSE_SEQ
:
1323 case OMP_CLAUSE_TILE
:
1324 case OMP_CLAUSE__SIMT_
:
1325 case OMP_CLAUSE_DEFAULT
:
1326 case OMP_CLAUSE_IF_PRESENT
:
1327 case OMP_CLAUSE_FINALIZE
:
1330 case OMP_CLAUSE_ALIGNED
:
1331 decl
= OMP_CLAUSE_DECL (c
);
1332 if (is_global_var (decl
)
1333 && TREE_CODE (TREE_TYPE (decl
)) == ARRAY_TYPE
)
1334 install_var_local (decl
, ctx
);
1337 case OMP_CLAUSE__CACHE_
:
1343 for (c
= clauses
; c
; c
= OMP_CLAUSE_CHAIN (c
))
1345 switch (OMP_CLAUSE_CODE (c
))
1347 case OMP_CLAUSE_LASTPRIVATE
:
1348 /* Let the corresponding firstprivate clause create
1350 if (OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (c
))
1351 scan_array_reductions
= true;
1352 if (OMP_CLAUSE_LASTPRIVATE_FIRSTPRIVATE (c
))
1356 case OMP_CLAUSE_FIRSTPRIVATE
:
1357 case OMP_CLAUSE_PRIVATE
:
1358 case OMP_CLAUSE_LINEAR
:
1359 case OMP_CLAUSE_IS_DEVICE_PTR
:
1360 decl
= OMP_CLAUSE_DECL (c
);
1361 if (is_variable_sized (decl
))
1363 if ((OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_FIRSTPRIVATE
1364 || OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_IS_DEVICE_PTR
)
1365 && is_gimple_omp_offloaded (ctx
->stmt
))
1367 tree decl2
= DECL_VALUE_EXPR (decl
);
1368 gcc_assert (TREE_CODE (decl2
) == INDIRECT_REF
);
1369 decl2
= TREE_OPERAND (decl2
, 0);
1370 gcc_assert (DECL_P (decl2
));
1371 install_var_local (decl2
, ctx
);
1372 fixup_remapped_decl (decl2
, ctx
, false);
1374 install_var_local (decl
, ctx
);
1376 fixup_remapped_decl (decl
, ctx
,
1377 OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_PRIVATE
1378 && OMP_CLAUSE_PRIVATE_DEBUG (c
));
1379 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_LINEAR
1380 && OMP_CLAUSE_LINEAR_GIMPLE_SEQ (c
))
1381 scan_array_reductions
= true;
1384 case OMP_CLAUSE_REDUCTION
:
1385 decl
= OMP_CLAUSE_DECL (c
);
1386 if (TREE_CODE (decl
) != MEM_REF
)
1388 if (is_variable_sized (decl
))
1389 install_var_local (decl
, ctx
);
1390 fixup_remapped_decl (decl
, ctx
, false);
1392 if (OMP_CLAUSE_REDUCTION_PLACEHOLDER (c
))
1393 scan_array_reductions
= true;
1396 case OMP_CLAUSE_SHARED
:
1397 /* Ignore shared directives in teams construct. */
1398 if (gimple_code (ctx
->stmt
) == GIMPLE_OMP_TEAMS
)
1400 decl
= OMP_CLAUSE_DECL (c
);
1401 if (is_global_var (maybe_lookup_decl_in_outer_ctx (decl
, ctx
)))
1403 if (OMP_CLAUSE_SHARED_FIRSTPRIVATE (c
))
1405 if (is_global_var (maybe_lookup_decl_in_outer_ctx (decl
,
1408 bool by_ref
= use_pointer_for_field (decl
, ctx
);
1409 install_var_field (decl
, by_ref
, 11, ctx
);
1412 fixup_remapped_decl (decl
, ctx
, false);
1415 case OMP_CLAUSE_MAP
:
1416 if (!is_gimple_omp_offloaded (ctx
->stmt
))
1418 decl
= OMP_CLAUSE_DECL (c
);
1420 && ((OMP_CLAUSE_MAP_KIND (c
) != GOMP_MAP_FIRSTPRIVATE_POINTER
1421 && (OMP_CLAUSE_MAP_KIND (c
)
1422 != GOMP_MAP_FIRSTPRIVATE_REFERENCE
))
1423 || TREE_CODE (TREE_TYPE (decl
)) == ARRAY_TYPE
)
1424 && is_global_var (maybe_lookup_decl_in_outer_ctx (decl
, ctx
))
1425 && varpool_node::get_create (decl
)->offloadable
)
1429 if ((OMP_CLAUSE_MAP_KIND (c
) == GOMP_MAP_POINTER
1430 || OMP_CLAUSE_MAP_KIND (c
) == GOMP_MAP_FIRSTPRIVATE_POINTER
)
1431 && TREE_CODE (TREE_TYPE (decl
)) == ARRAY_TYPE
1432 && !COMPLETE_TYPE_P (TREE_TYPE (decl
)))
1434 tree new_decl
= lookup_decl (decl
, ctx
);
1435 TREE_TYPE (new_decl
)
1436 = remap_type (TREE_TYPE (decl
), &ctx
->cb
);
1438 else if (DECL_SIZE (decl
)
1439 && TREE_CODE (DECL_SIZE (decl
)) != INTEGER_CST
)
1441 tree decl2
= DECL_VALUE_EXPR (decl
);
1442 gcc_assert (TREE_CODE (decl2
) == INDIRECT_REF
);
1443 decl2
= TREE_OPERAND (decl2
, 0);
1444 gcc_assert (DECL_P (decl2
));
1445 fixup_remapped_decl (decl2
, ctx
, false);
1446 fixup_remapped_decl (decl
, ctx
, true);
1449 fixup_remapped_decl (decl
, ctx
, false);
1453 case OMP_CLAUSE_COPYPRIVATE
:
1454 case OMP_CLAUSE_COPYIN
:
1455 case OMP_CLAUSE_DEFAULT
:
1457 case OMP_CLAUSE_NUM_THREADS
:
1458 case OMP_CLAUSE_NUM_TEAMS
:
1459 case OMP_CLAUSE_THREAD_LIMIT
:
1460 case OMP_CLAUSE_DEVICE
:
1461 case OMP_CLAUSE_SCHEDULE
:
1462 case OMP_CLAUSE_DIST_SCHEDULE
:
1463 case OMP_CLAUSE_NOWAIT
:
1464 case OMP_CLAUSE_ORDERED
:
1465 case OMP_CLAUSE_COLLAPSE
:
1466 case OMP_CLAUSE_UNTIED
:
1467 case OMP_CLAUSE_FINAL
:
1468 case OMP_CLAUSE_MERGEABLE
:
1469 case OMP_CLAUSE_PROC_BIND
:
1470 case OMP_CLAUSE_SAFELEN
:
1471 case OMP_CLAUSE_SIMDLEN
:
1472 case OMP_CLAUSE_ALIGNED
:
1473 case OMP_CLAUSE_DEPEND
:
1474 case OMP_CLAUSE__LOOPTEMP_
:
1476 case OMP_CLAUSE_FROM
:
1477 case OMP_CLAUSE_PRIORITY
:
1478 case OMP_CLAUSE_GRAINSIZE
:
1479 case OMP_CLAUSE_NUM_TASKS
:
1480 case OMP_CLAUSE_THREADS
:
1481 case OMP_CLAUSE_SIMD
:
1482 case OMP_CLAUSE_NOGROUP
:
1483 case OMP_CLAUSE_DEFAULTMAP
:
1484 case OMP_CLAUSE_USE_DEVICE_PTR
:
1485 case OMP_CLAUSE_ASYNC
:
1486 case OMP_CLAUSE_WAIT
:
1487 case OMP_CLAUSE_NUM_GANGS
:
1488 case OMP_CLAUSE_NUM_WORKERS
:
1489 case OMP_CLAUSE_VECTOR_LENGTH
:
1490 case OMP_CLAUSE_GANG
:
1491 case OMP_CLAUSE_WORKER
:
1492 case OMP_CLAUSE_VECTOR
:
1493 case OMP_CLAUSE_INDEPENDENT
:
1494 case OMP_CLAUSE_AUTO
:
1495 case OMP_CLAUSE_SEQ
:
1496 case OMP_CLAUSE_TILE
:
1497 case OMP_CLAUSE__GRIDDIM_
:
1498 case OMP_CLAUSE__SIMT_
:
1499 case OMP_CLAUSE_IF_PRESENT
:
1500 case OMP_CLAUSE_FINALIZE
:
1503 case OMP_CLAUSE__CACHE_
:
1509 gcc_checking_assert (!scan_array_reductions
1510 || !is_gimple_omp_oacc (ctx
->stmt
));
1511 if (scan_array_reductions
)
1513 for (c
= clauses
; c
; c
= OMP_CLAUSE_CHAIN (c
))
1514 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_REDUCTION
1515 && OMP_CLAUSE_REDUCTION_PLACEHOLDER (c
))
1517 scan_omp (&OMP_CLAUSE_REDUCTION_GIMPLE_INIT (c
), ctx
);
1518 scan_omp (&OMP_CLAUSE_REDUCTION_GIMPLE_MERGE (c
), ctx
);
1520 else if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_LASTPRIVATE
1521 && OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (c
))
1522 scan_omp (&OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (c
), ctx
);
1523 else if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_LINEAR
1524 && OMP_CLAUSE_LINEAR_GIMPLE_SEQ (c
))
1525 scan_omp (&OMP_CLAUSE_LINEAR_GIMPLE_SEQ (c
), ctx
);
1529 /* Create a new name for omp child function. Returns an identifier. */
1532 create_omp_child_function_name (bool task_copy
)
1534 return clone_function_name (current_function_decl
,
1535 task_copy
? "_omp_cpyfn" : "_omp_fn");
1538 /* Return true if CTX may belong to offloaded code: either if current function
1539 is offloaded, or any enclosing context corresponds to a target region. */
1542 omp_maybe_offloaded_ctx (omp_context
*ctx
)
1544 if (cgraph_node::get (current_function_decl
)->offloadable
)
1546 for (; ctx
; ctx
= ctx
->outer
)
1547 if (is_gimple_omp_offloaded (ctx
->stmt
))
1552 /* Build a decl for the omp child function. It'll not contain a body
1553 yet, just the bare decl. */
1556 create_omp_child_function (omp_context
*ctx
, bool task_copy
)
1558 tree decl
, type
, name
, t
;
1560 name
= create_omp_child_function_name (task_copy
);
1562 type
= build_function_type_list (void_type_node
, ptr_type_node
,
1563 ptr_type_node
, NULL_TREE
);
1565 type
= build_function_type_list (void_type_node
, ptr_type_node
, NULL_TREE
);
1567 decl
= build_decl (gimple_location (ctx
->stmt
), FUNCTION_DECL
, name
, type
);
1569 gcc_checking_assert (!is_gimple_omp_oacc (ctx
->stmt
)
1572 ctx
->cb
.dst_fn
= decl
;
1574 gimple_omp_task_set_copy_fn (ctx
->stmt
, decl
);
1576 TREE_STATIC (decl
) = 1;
1577 TREE_USED (decl
) = 1;
1578 DECL_ARTIFICIAL (decl
) = 1;
1579 DECL_IGNORED_P (decl
) = 0;
1580 TREE_PUBLIC (decl
) = 0;
1581 DECL_UNINLINABLE (decl
) = 1;
1582 DECL_EXTERNAL (decl
) = 0;
1583 DECL_CONTEXT (decl
) = NULL_TREE
;
1584 DECL_INITIAL (decl
) = make_node (BLOCK
);
1585 BLOCK_SUPERCONTEXT (DECL_INITIAL (decl
)) = decl
;
1586 DECL_ATTRIBUTES (decl
) = DECL_ATTRIBUTES (current_function_decl
);
1587 /* Remove omp declare simd attribute from the new attributes. */
1588 if (tree a
= lookup_attribute ("omp declare simd", DECL_ATTRIBUTES (decl
)))
1590 while (tree a2
= lookup_attribute ("omp declare simd", TREE_CHAIN (a
)))
1593 for (tree
*p
= &DECL_ATTRIBUTES (decl
); *p
!= a
;)
1594 if (is_attribute_p ("omp declare simd", get_attribute_name (*p
)))
1595 *p
= TREE_CHAIN (*p
);
1598 tree chain
= TREE_CHAIN (*p
);
1599 *p
= copy_node (*p
);
1600 p
= &TREE_CHAIN (*p
);
1604 DECL_FUNCTION_SPECIFIC_OPTIMIZATION (decl
)
1605 = DECL_FUNCTION_SPECIFIC_OPTIMIZATION (current_function_decl
);
1606 DECL_FUNCTION_SPECIFIC_TARGET (decl
)
1607 = DECL_FUNCTION_SPECIFIC_TARGET (current_function_decl
);
1608 DECL_FUNCTION_VERSIONED (decl
)
1609 = DECL_FUNCTION_VERSIONED (current_function_decl
);
1611 if (omp_maybe_offloaded_ctx (ctx
))
1613 cgraph_node::get_create (decl
)->offloadable
= 1;
1614 if (ENABLE_OFFLOADING
)
1615 g
->have_offload
= true;
1618 if (cgraph_node::get_create (decl
)->offloadable
1619 && !lookup_attribute ("omp declare target",
1620 DECL_ATTRIBUTES (current_function_decl
)))
1622 const char *target_attr
= (is_gimple_omp_offloaded (ctx
->stmt
)
1623 ? "omp target entrypoint"
1624 : "omp declare target");
1625 DECL_ATTRIBUTES (decl
)
1626 = tree_cons (get_identifier (target_attr
),
1627 NULL_TREE
, DECL_ATTRIBUTES (decl
));
1630 t
= build_decl (DECL_SOURCE_LOCATION (decl
),
1631 RESULT_DECL
, NULL_TREE
, void_type_node
);
1632 DECL_ARTIFICIAL (t
) = 1;
1633 DECL_IGNORED_P (t
) = 1;
1634 DECL_CONTEXT (t
) = decl
;
1635 DECL_RESULT (decl
) = t
;
1637 tree data_name
= get_identifier (".omp_data_i");
1638 t
= build_decl (DECL_SOURCE_LOCATION (decl
), PARM_DECL
, data_name
,
1640 DECL_ARTIFICIAL (t
) = 1;
1641 DECL_NAMELESS (t
) = 1;
1642 DECL_ARG_TYPE (t
) = ptr_type_node
;
1643 DECL_CONTEXT (t
) = current_function_decl
;
1645 TREE_READONLY (t
) = 1;
1646 DECL_ARGUMENTS (decl
) = t
;
1648 ctx
->receiver_decl
= t
;
1651 t
= build_decl (DECL_SOURCE_LOCATION (decl
),
1652 PARM_DECL
, get_identifier (".omp_data_o"),
1654 DECL_ARTIFICIAL (t
) = 1;
1655 DECL_NAMELESS (t
) = 1;
1656 DECL_ARG_TYPE (t
) = ptr_type_node
;
1657 DECL_CONTEXT (t
) = current_function_decl
;
1659 TREE_ADDRESSABLE (t
) = 1;
1660 DECL_CHAIN (t
) = DECL_ARGUMENTS (decl
);
1661 DECL_ARGUMENTS (decl
) = t
;
1664 /* Allocate memory for the function structure. The call to
1665 allocate_struct_function clobbers CFUN, so we need to restore
1667 push_struct_function (decl
);
1668 cfun
->function_end_locus
= gimple_location (ctx
->stmt
);
1669 init_tree_ssa (cfun
);
1673 /* Callback for walk_gimple_seq. Check if combined parallel
1674 contains gimple_omp_for_combined_into_p OMP_FOR. */
1677 omp_find_combined_for (gimple_stmt_iterator
*gsi_p
,
1678 bool *handled_ops_p
,
1679 struct walk_stmt_info
*wi
)
1681 gimple
*stmt
= gsi_stmt (*gsi_p
);
1683 *handled_ops_p
= true;
1684 switch (gimple_code (stmt
))
1688 case GIMPLE_OMP_FOR
:
1689 if (gimple_omp_for_combined_into_p (stmt
)
1690 && gimple_omp_for_kind (stmt
)
1691 == *(const enum gf_mask
*) (wi
->info
))
1694 return integer_zero_node
;
1703 /* Add _LOOPTEMP_ clauses on OpenMP parallel or task. */
1706 add_taskreg_looptemp_clauses (enum gf_mask msk
, gimple
*stmt
,
1707 omp_context
*outer_ctx
)
1709 struct walk_stmt_info wi
;
1711 memset (&wi
, 0, sizeof (wi
));
1713 wi
.info
= (void *) &msk
;
1714 walk_gimple_seq (gimple_omp_body (stmt
), omp_find_combined_for
, NULL
, &wi
);
1715 if (wi
.info
!= (void *) &msk
)
1717 gomp_for
*for_stmt
= as_a
<gomp_for
*> ((gimple
*) wi
.info
);
1718 struct omp_for_data fd
;
1719 omp_extract_for_data (for_stmt
, &fd
, NULL
);
1720 /* We need two temporaries with fd.loop.v type (istart/iend)
1721 and then (fd.collapse - 1) temporaries with the same
1722 type for count2 ... countN-1 vars if not constant. */
1723 size_t count
= 2, i
;
1724 tree type
= fd
.iter_type
;
1726 && TREE_CODE (fd
.loop
.n2
) != INTEGER_CST
)
1728 count
+= fd
.collapse
- 1;
1729 /* If there are lastprivate clauses on the inner
1730 GIMPLE_OMP_FOR, add one more temporaries for the total number
1731 of iterations (product of count1 ... countN-1). */
1732 if (omp_find_clause (gimple_omp_for_clauses (for_stmt
),
1733 OMP_CLAUSE_LASTPRIVATE
))
1735 else if (msk
== GF_OMP_FOR_KIND_FOR
1736 && omp_find_clause (gimple_omp_parallel_clauses (stmt
),
1737 OMP_CLAUSE_LASTPRIVATE
))
1740 for (i
= 0; i
< count
; i
++)
1742 tree temp
= create_tmp_var (type
);
1743 tree c
= build_omp_clause (UNKNOWN_LOCATION
, OMP_CLAUSE__LOOPTEMP_
);
1744 insert_decl_map (&outer_ctx
->cb
, temp
, temp
);
1745 OMP_CLAUSE_DECL (c
) = temp
;
1746 OMP_CLAUSE_CHAIN (c
) = gimple_omp_taskreg_clauses (stmt
);
1747 gimple_omp_taskreg_set_clauses (stmt
, c
);
1752 /* Scan an OpenMP parallel directive. */
1755 scan_omp_parallel (gimple_stmt_iterator
*gsi
, omp_context
*outer_ctx
)
1759 gomp_parallel
*stmt
= as_a
<gomp_parallel
*> (gsi_stmt (*gsi
));
1761 /* Ignore parallel directives with empty bodies, unless there
1762 are copyin clauses. */
1764 && empty_body_p (gimple_omp_body (stmt
))
1765 && omp_find_clause (gimple_omp_parallel_clauses (stmt
),
1766 OMP_CLAUSE_COPYIN
) == NULL
)
1768 gsi_replace (gsi
, gimple_build_nop (), false);
1772 if (gimple_omp_parallel_combined_p (stmt
))
1773 add_taskreg_looptemp_clauses (GF_OMP_FOR_KIND_FOR
, stmt
, outer_ctx
);
1775 ctx
= new_omp_context (stmt
, outer_ctx
);
1776 taskreg_contexts
.safe_push (ctx
);
1777 if (taskreg_nesting_level
> 1)
1778 ctx
->is_nested
= true;
1779 ctx
->field_map
= splay_tree_new (splay_tree_compare_pointers
, 0, 0);
1780 ctx
->record_type
= lang_hooks
.types
.make_type (RECORD_TYPE
);
1781 name
= create_tmp_var_name (".omp_data_s");
1782 name
= build_decl (gimple_location (stmt
),
1783 TYPE_DECL
, name
, ctx
->record_type
);
1784 DECL_ARTIFICIAL (name
) = 1;
1785 DECL_NAMELESS (name
) = 1;
1786 TYPE_NAME (ctx
->record_type
) = name
;
1787 TYPE_ARTIFICIAL (ctx
->record_type
) = 1;
1788 if (!gimple_omp_parallel_grid_phony (stmt
))
1790 create_omp_child_function (ctx
, false);
1791 gimple_omp_parallel_set_child_fn (stmt
, ctx
->cb
.dst_fn
);
1794 scan_sharing_clauses (gimple_omp_parallel_clauses (stmt
), ctx
);
1795 scan_omp (gimple_omp_body_ptr (stmt
), ctx
);
1797 if (TYPE_FIELDS (ctx
->record_type
) == NULL
)
1798 ctx
->record_type
= ctx
->receiver_decl
= NULL
;
1801 /* Scan an OpenMP task directive. */
1804 scan_omp_task (gimple_stmt_iterator
*gsi
, omp_context
*outer_ctx
)
1808 gomp_task
*stmt
= as_a
<gomp_task
*> (gsi_stmt (*gsi
));
1810 /* Ignore task directives with empty bodies, unless they have depend
1813 && empty_body_p (gimple_omp_body (stmt
))
1814 && !omp_find_clause (gimple_omp_task_clauses (stmt
), OMP_CLAUSE_DEPEND
))
1816 gsi_replace (gsi
, gimple_build_nop (), false);
1820 if (gimple_omp_task_taskloop_p (stmt
))
1821 add_taskreg_looptemp_clauses (GF_OMP_FOR_KIND_TASKLOOP
, stmt
, outer_ctx
);
1823 ctx
= new_omp_context (stmt
, outer_ctx
);
1824 taskreg_contexts
.safe_push (ctx
);
1825 if (taskreg_nesting_level
> 1)
1826 ctx
->is_nested
= true;
1827 ctx
->field_map
= splay_tree_new (splay_tree_compare_pointers
, 0, 0);
1828 ctx
->record_type
= lang_hooks
.types
.make_type (RECORD_TYPE
);
1829 name
= create_tmp_var_name (".omp_data_s");
1830 name
= build_decl (gimple_location (stmt
),
1831 TYPE_DECL
, name
, ctx
->record_type
);
1832 DECL_ARTIFICIAL (name
) = 1;
1833 DECL_NAMELESS (name
) = 1;
1834 TYPE_NAME (ctx
->record_type
) = name
;
1835 TYPE_ARTIFICIAL (ctx
->record_type
) = 1;
1836 create_omp_child_function (ctx
, false);
1837 gimple_omp_task_set_child_fn (stmt
, ctx
->cb
.dst_fn
);
1839 scan_sharing_clauses (gimple_omp_task_clauses (stmt
), ctx
);
1841 if (ctx
->srecord_type
)
1843 name
= create_tmp_var_name (".omp_data_a");
1844 name
= build_decl (gimple_location (stmt
),
1845 TYPE_DECL
, name
, ctx
->srecord_type
);
1846 DECL_ARTIFICIAL (name
) = 1;
1847 DECL_NAMELESS (name
) = 1;
1848 TYPE_NAME (ctx
->srecord_type
) = name
;
1849 TYPE_ARTIFICIAL (ctx
->srecord_type
) = 1;
1850 create_omp_child_function (ctx
, true);
1853 scan_omp (gimple_omp_body_ptr (stmt
), ctx
);
1855 if (TYPE_FIELDS (ctx
->record_type
) == NULL
)
1857 ctx
->record_type
= ctx
->receiver_decl
= NULL
;
1858 t
= build_int_cst (long_integer_type_node
, 0);
1859 gimple_omp_task_set_arg_size (stmt
, t
);
1860 t
= build_int_cst (long_integer_type_node
, 1);
1861 gimple_omp_task_set_arg_align (stmt
, t
);
1865 /* Helper function for finish_taskreg_scan, called through walk_tree.
1866 If maybe_lookup_decl_in_outer_context returns non-NULL for some
1867 tree, replace it in the expression. */
1870 finish_taskreg_remap (tree
*tp
, int *walk_subtrees
, void *data
)
1874 omp_context
*ctx
= (omp_context
*) data
;
1875 tree t
= maybe_lookup_decl_in_outer_ctx (*tp
, ctx
);
1878 if (DECL_HAS_VALUE_EXPR_P (t
))
1879 t
= unshare_expr (DECL_VALUE_EXPR (t
));
1884 else if (IS_TYPE_OR_DECL_P (*tp
))
1889 /* If any decls have been made addressable during scan_omp,
1890 adjust their fields if needed, and layout record types
1891 of parallel/task constructs. */
1894 finish_taskreg_scan (omp_context
*ctx
)
1896 if (ctx
->record_type
== NULL_TREE
)
1899 /* If any task_shared_vars were needed, verify all
1900 OMP_CLAUSE_SHARED clauses on GIMPLE_OMP_{PARALLEL,TASK}
1901 statements if use_pointer_for_field hasn't changed
1902 because of that. If it did, update field types now. */
1903 if (task_shared_vars
)
1907 for (c
= gimple_omp_taskreg_clauses (ctx
->stmt
);
1908 c
; c
= OMP_CLAUSE_CHAIN (c
))
1909 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_SHARED
1910 && !OMP_CLAUSE_SHARED_FIRSTPRIVATE (c
))
1912 tree decl
= OMP_CLAUSE_DECL (c
);
1914 /* Global variables don't need to be copied,
1915 the receiver side will use them directly. */
1916 if (is_global_var (maybe_lookup_decl_in_outer_ctx (decl
, ctx
)))
1918 if (!bitmap_bit_p (task_shared_vars
, DECL_UID (decl
))
1919 || !use_pointer_for_field (decl
, ctx
))
1921 tree field
= lookup_field (decl
, ctx
);
1922 if (TREE_CODE (TREE_TYPE (field
)) == POINTER_TYPE
1923 && TREE_TYPE (TREE_TYPE (field
)) == TREE_TYPE (decl
))
1925 TREE_TYPE (field
) = build_pointer_type (TREE_TYPE (decl
));
1926 TREE_THIS_VOLATILE (field
) = 0;
1927 DECL_USER_ALIGN (field
) = 0;
1928 SET_DECL_ALIGN (field
, TYPE_ALIGN (TREE_TYPE (field
)));
1929 if (TYPE_ALIGN (ctx
->record_type
) < DECL_ALIGN (field
))
1930 SET_TYPE_ALIGN (ctx
->record_type
, DECL_ALIGN (field
));
1931 if (ctx
->srecord_type
)
1933 tree sfield
= lookup_sfield (decl
, ctx
);
1934 TREE_TYPE (sfield
) = TREE_TYPE (field
);
1935 TREE_THIS_VOLATILE (sfield
) = 0;
1936 DECL_USER_ALIGN (sfield
) = 0;
1937 SET_DECL_ALIGN (sfield
, DECL_ALIGN (field
));
1938 if (TYPE_ALIGN (ctx
->srecord_type
) < DECL_ALIGN (sfield
))
1939 SET_TYPE_ALIGN (ctx
->srecord_type
, DECL_ALIGN (sfield
));
1944 if (gimple_code (ctx
->stmt
) == GIMPLE_OMP_PARALLEL
)
1946 layout_type (ctx
->record_type
);
1947 fixup_child_record_type (ctx
);
1951 location_t loc
= gimple_location (ctx
->stmt
);
1952 tree
*p
, vla_fields
= NULL_TREE
, *q
= &vla_fields
;
1953 /* Move VLA fields to the end. */
1954 p
= &TYPE_FIELDS (ctx
->record_type
);
1956 if (!TYPE_SIZE_UNIT (TREE_TYPE (*p
))
1957 || ! TREE_CONSTANT (TYPE_SIZE_UNIT (TREE_TYPE (*p
))))
1960 *p
= TREE_CHAIN (*p
);
1961 TREE_CHAIN (*q
) = NULL_TREE
;
1962 q
= &TREE_CHAIN (*q
);
1965 p
= &DECL_CHAIN (*p
);
1967 if (gimple_omp_task_taskloop_p (ctx
->stmt
))
1969 /* Move fields corresponding to first and second _looptemp_
1970 clause first. There are filled by GOMP_taskloop
1971 and thus need to be in specific positions. */
1972 tree c1
= gimple_omp_task_clauses (ctx
->stmt
);
1973 c1
= omp_find_clause (c1
, OMP_CLAUSE__LOOPTEMP_
);
1974 tree c2
= omp_find_clause (OMP_CLAUSE_CHAIN (c1
),
1975 OMP_CLAUSE__LOOPTEMP_
);
1976 tree f1
= lookup_field (OMP_CLAUSE_DECL (c1
), ctx
);
1977 tree f2
= lookup_field (OMP_CLAUSE_DECL (c2
), ctx
);
1978 p
= &TYPE_FIELDS (ctx
->record_type
);
1980 if (*p
== f1
|| *p
== f2
)
1981 *p
= DECL_CHAIN (*p
);
1983 p
= &DECL_CHAIN (*p
);
1984 DECL_CHAIN (f1
) = f2
;
1985 DECL_CHAIN (f2
) = TYPE_FIELDS (ctx
->record_type
);
1986 TYPE_FIELDS (ctx
->record_type
) = f1
;
1987 if (ctx
->srecord_type
)
1989 f1
= lookup_sfield (OMP_CLAUSE_DECL (c1
), ctx
);
1990 f2
= lookup_sfield (OMP_CLAUSE_DECL (c2
), ctx
);
1991 p
= &TYPE_FIELDS (ctx
->srecord_type
);
1993 if (*p
== f1
|| *p
== f2
)
1994 *p
= DECL_CHAIN (*p
);
1996 p
= &DECL_CHAIN (*p
);
1997 DECL_CHAIN (f1
) = f2
;
1998 DECL_CHAIN (f2
) = TYPE_FIELDS (ctx
->srecord_type
);
1999 TYPE_FIELDS (ctx
->srecord_type
) = f1
;
2002 layout_type (ctx
->record_type
);
2003 fixup_child_record_type (ctx
);
2004 if (ctx
->srecord_type
)
2005 layout_type (ctx
->srecord_type
);
2006 tree t
= fold_convert_loc (loc
, long_integer_type_node
,
2007 TYPE_SIZE_UNIT (ctx
->record_type
));
2008 if (TREE_CODE (t
) != INTEGER_CST
)
2010 t
= unshare_expr (t
);
2011 walk_tree (&t
, finish_taskreg_remap
, ctx
, NULL
);
2013 gimple_omp_task_set_arg_size (ctx
->stmt
, t
);
2014 t
= build_int_cst (long_integer_type_node
,
2015 TYPE_ALIGN_UNIT (ctx
->record_type
));
2016 gimple_omp_task_set_arg_align (ctx
->stmt
, t
);
2020 /* Find the enclosing offload context. */
2022 static omp_context
*
2023 enclosing_target_ctx (omp_context
*ctx
)
2025 for (; ctx
; ctx
= ctx
->outer
)
2026 if (gimple_code (ctx
->stmt
) == GIMPLE_OMP_TARGET
)
2032 /* Return true if ctx is part of an oacc kernels region. */
2035 ctx_in_oacc_kernels_region (omp_context
*ctx
)
2037 for (;ctx
!= NULL
; ctx
= ctx
->outer
)
2039 gimple
*stmt
= ctx
->stmt
;
2040 if (gimple_code (stmt
) == GIMPLE_OMP_TARGET
2041 && gimple_omp_target_kind (stmt
) == GF_OMP_TARGET_KIND_OACC_KERNELS
)
2048 /* Check the parallelism clauses inside a kernels regions.
2049 Until kernels handling moves to use the same loop indirection
2050 scheme as parallel, we need to do this checking early. */
2053 check_oacc_kernel_gwv (gomp_for
*stmt
, omp_context
*ctx
)
2055 bool checking
= true;
2056 unsigned outer_mask
= 0;
2057 unsigned this_mask
= 0;
2058 bool has_seq
= false, has_auto
= false;
2061 outer_mask
= check_oacc_kernel_gwv (NULL
, ctx
->outer
);
2065 if (gimple_code (ctx
->stmt
) != GIMPLE_OMP_FOR
)
2067 stmt
= as_a
<gomp_for
*> (ctx
->stmt
);
2070 for (tree c
= gimple_omp_for_clauses (stmt
); c
; c
= OMP_CLAUSE_CHAIN (c
))
2072 switch (OMP_CLAUSE_CODE (c
))
2074 case OMP_CLAUSE_GANG
:
2075 this_mask
|= GOMP_DIM_MASK (GOMP_DIM_GANG
);
2077 case OMP_CLAUSE_WORKER
:
2078 this_mask
|= GOMP_DIM_MASK (GOMP_DIM_WORKER
);
2080 case OMP_CLAUSE_VECTOR
:
2081 this_mask
|= GOMP_DIM_MASK (GOMP_DIM_VECTOR
);
2083 case OMP_CLAUSE_SEQ
:
2086 case OMP_CLAUSE_AUTO
:
2096 if (has_seq
&& (this_mask
|| has_auto
))
2097 error_at (gimple_location (stmt
), "%<seq%> overrides other"
2098 " OpenACC loop specifiers");
2099 else if (has_auto
&& this_mask
)
2100 error_at (gimple_location (stmt
), "%<auto%> conflicts with other"
2101 " OpenACC loop specifiers");
2103 if (this_mask
& outer_mask
)
2104 error_at (gimple_location (stmt
), "inner loop uses same"
2105 " OpenACC parallelism as containing loop");
2108 return outer_mask
| this_mask
;
2111 /* Scan a GIMPLE_OMP_FOR. */
2113 static omp_context
*
2114 scan_omp_for (gomp_for
*stmt
, omp_context
*outer_ctx
)
2118 tree clauses
= gimple_omp_for_clauses (stmt
);
2120 ctx
= new_omp_context (stmt
, outer_ctx
);
2122 if (is_gimple_omp_oacc (stmt
))
2124 omp_context
*tgt
= enclosing_target_ctx (outer_ctx
);
2126 if (!tgt
|| is_oacc_parallel (tgt
))
2127 for (tree c
= clauses
; c
; c
= OMP_CLAUSE_CHAIN (c
))
2129 char const *check
= NULL
;
2131 switch (OMP_CLAUSE_CODE (c
))
2133 case OMP_CLAUSE_GANG
:
2137 case OMP_CLAUSE_WORKER
:
2141 case OMP_CLAUSE_VECTOR
:
2149 if (check
&& OMP_CLAUSE_OPERAND (c
, 0))
2150 error_at (gimple_location (stmt
),
2151 "argument not permitted on %qs clause in"
2152 " OpenACC %<parallel%>", check
);
2155 if (tgt
&& is_oacc_kernels (tgt
))
2157 /* Strip out reductions, as they are not handled yet. */
2158 tree
*prev_ptr
= &clauses
;
2160 while (tree probe
= *prev_ptr
)
2162 tree
*next_ptr
= &OMP_CLAUSE_CHAIN (probe
);
2164 if (OMP_CLAUSE_CODE (probe
) == OMP_CLAUSE_REDUCTION
)
2165 *prev_ptr
= *next_ptr
;
2167 prev_ptr
= next_ptr
;
2170 gimple_omp_for_set_clauses (stmt
, clauses
);
2171 check_oacc_kernel_gwv (stmt
, ctx
);
2175 scan_sharing_clauses (clauses
, ctx
);
2177 scan_omp (gimple_omp_for_pre_body_ptr (stmt
), ctx
);
2178 for (i
= 0; i
< gimple_omp_for_collapse (stmt
); i
++)
2180 scan_omp_op (gimple_omp_for_index_ptr (stmt
, i
), ctx
);
2181 scan_omp_op (gimple_omp_for_initial_ptr (stmt
, i
), ctx
);
2182 scan_omp_op (gimple_omp_for_final_ptr (stmt
, i
), ctx
);
2183 scan_omp_op (gimple_omp_for_incr_ptr (stmt
, i
), ctx
);
2185 scan_omp (gimple_omp_body_ptr (stmt
), ctx
);
2189 /* Duplicate #pragma omp simd, one for SIMT, another one for SIMD. */
2192 scan_omp_simd (gimple_stmt_iterator
*gsi
, gomp_for
*stmt
,
2193 omp_context
*outer_ctx
)
2195 gbind
*bind
= gimple_build_bind (NULL
, NULL
, NULL
);
2196 gsi_replace (gsi
, bind
, false);
2197 gimple_seq seq
= NULL
;
2198 gimple
*g
= gimple_build_call_internal (IFN_GOMP_USE_SIMT
, 0);
2199 tree cond
= create_tmp_var_raw (integer_type_node
);
2200 DECL_CONTEXT (cond
) = current_function_decl
;
2201 DECL_SEEN_IN_BIND_EXPR_P (cond
) = 1;
2202 gimple_bind_set_vars (bind
, cond
);
2203 gimple_call_set_lhs (g
, cond
);
2204 gimple_seq_add_stmt (&seq
, g
);
2205 tree lab1
= create_artificial_label (UNKNOWN_LOCATION
);
2206 tree lab2
= create_artificial_label (UNKNOWN_LOCATION
);
2207 tree lab3
= create_artificial_label (UNKNOWN_LOCATION
);
2208 g
= gimple_build_cond (NE_EXPR
, cond
, integer_zero_node
, lab1
, lab2
);
2209 gimple_seq_add_stmt (&seq
, g
);
2210 g
= gimple_build_label (lab1
);
2211 gimple_seq_add_stmt (&seq
, g
);
2212 gimple_seq new_seq
= copy_gimple_seq_and_replace_locals (stmt
);
2213 gomp_for
*new_stmt
= as_a
<gomp_for
*> (new_seq
);
2214 tree clause
= build_omp_clause (gimple_location (stmt
), OMP_CLAUSE__SIMT_
);
2215 OMP_CLAUSE_CHAIN (clause
) = gimple_omp_for_clauses (new_stmt
);
2216 gimple_omp_for_set_clauses (new_stmt
, clause
);
2217 gimple_seq_add_stmt (&seq
, new_stmt
);
2218 g
= gimple_build_goto (lab3
);
2219 gimple_seq_add_stmt (&seq
, g
);
2220 g
= gimple_build_label (lab2
);
2221 gimple_seq_add_stmt (&seq
, g
);
2222 gimple_seq_add_stmt (&seq
, stmt
);
2223 g
= gimple_build_label (lab3
);
2224 gimple_seq_add_stmt (&seq
, g
);
2225 gimple_bind_set_body (bind
, seq
);
2227 scan_omp_for (new_stmt
, outer_ctx
);
2228 scan_omp_for (stmt
, outer_ctx
)->simt_stmt
= new_stmt
;
2231 /* Scan an OpenMP sections directive. */
2234 scan_omp_sections (gomp_sections
*stmt
, omp_context
*outer_ctx
)
2238 ctx
= new_omp_context (stmt
, outer_ctx
);
2239 scan_sharing_clauses (gimple_omp_sections_clauses (stmt
), ctx
);
2240 scan_omp (gimple_omp_body_ptr (stmt
), ctx
);
2243 /* Scan an OpenMP single directive. */
2246 scan_omp_single (gomp_single
*stmt
, omp_context
*outer_ctx
)
2251 ctx
= new_omp_context (stmt
, outer_ctx
);
2252 ctx
->field_map
= splay_tree_new (splay_tree_compare_pointers
, 0, 0);
2253 ctx
->record_type
= lang_hooks
.types
.make_type (RECORD_TYPE
);
2254 name
= create_tmp_var_name (".omp_copy_s");
2255 name
= build_decl (gimple_location (stmt
),
2256 TYPE_DECL
, name
, ctx
->record_type
);
2257 TYPE_NAME (ctx
->record_type
) = name
;
2259 scan_sharing_clauses (gimple_omp_single_clauses (stmt
), ctx
);
2260 scan_omp (gimple_omp_body_ptr (stmt
), ctx
);
2262 if (TYPE_FIELDS (ctx
->record_type
) == NULL
)
2263 ctx
->record_type
= NULL
;
2265 layout_type (ctx
->record_type
);
2268 /* Scan a GIMPLE_OMP_TARGET. */
2271 scan_omp_target (gomp_target
*stmt
, omp_context
*outer_ctx
)
2275 bool offloaded
= is_gimple_omp_offloaded (stmt
);
2276 tree clauses
= gimple_omp_target_clauses (stmt
);
2278 ctx
= new_omp_context (stmt
, outer_ctx
);
2279 ctx
->field_map
= splay_tree_new (splay_tree_compare_pointers
, 0, 0);
2280 ctx
->record_type
= lang_hooks
.types
.make_type (RECORD_TYPE
);
2281 name
= create_tmp_var_name (".omp_data_t");
2282 name
= build_decl (gimple_location (stmt
),
2283 TYPE_DECL
, name
, ctx
->record_type
);
2284 DECL_ARTIFICIAL (name
) = 1;
2285 DECL_NAMELESS (name
) = 1;
2286 TYPE_NAME (ctx
->record_type
) = name
;
2287 TYPE_ARTIFICIAL (ctx
->record_type
) = 1;
2291 create_omp_child_function (ctx
, false);
2292 gimple_omp_target_set_child_fn (stmt
, ctx
->cb
.dst_fn
);
2295 scan_sharing_clauses (clauses
, ctx
);
2296 scan_omp (gimple_omp_body_ptr (stmt
), ctx
);
2298 if (TYPE_FIELDS (ctx
->record_type
) == NULL
)
2299 ctx
->record_type
= ctx
->receiver_decl
= NULL
;
2302 TYPE_FIELDS (ctx
->record_type
)
2303 = nreverse (TYPE_FIELDS (ctx
->record_type
));
2306 unsigned int align
= DECL_ALIGN (TYPE_FIELDS (ctx
->record_type
));
2307 for (tree field
= TYPE_FIELDS (ctx
->record_type
);
2309 field
= DECL_CHAIN (field
))
2310 gcc_assert (DECL_ALIGN (field
) == align
);
2312 layout_type (ctx
->record_type
);
2314 fixup_child_record_type (ctx
);
2318 /* Scan an OpenMP teams directive. */
2321 scan_omp_teams (gomp_teams
*stmt
, omp_context
*outer_ctx
)
2323 omp_context
*ctx
= new_omp_context (stmt
, outer_ctx
);
2324 scan_sharing_clauses (gimple_omp_teams_clauses (stmt
), ctx
);
2325 scan_omp (gimple_omp_body_ptr (stmt
), ctx
);
2328 /* Check nesting restrictions. */
2330 check_omp_nesting_restrictions (gimple
*stmt
, omp_context
*ctx
)
2334 if (ctx
&& gimple_code (ctx
->stmt
) == GIMPLE_OMP_GRID_BODY
)
2335 /* GRID_BODY is an artificial construct, nesting rules will be checked in
2336 the original copy of its contents. */
2339 /* No nesting of non-OpenACC STMT (that is, an OpenMP one, or a GOMP builtin)
2340 inside an OpenACC CTX. */
2341 if (!(is_gimple_omp (stmt
)
2342 && is_gimple_omp_oacc (stmt
))
2343 /* Except for atomic codes that we share with OpenMP. */
2344 && !(gimple_code (stmt
) == GIMPLE_OMP_ATOMIC_LOAD
2345 || gimple_code (stmt
) == GIMPLE_OMP_ATOMIC_STORE
))
2347 if (oacc_get_fn_attrib (cfun
->decl
) != NULL
)
2349 error_at (gimple_location (stmt
),
2350 "non-OpenACC construct inside of OpenACC routine");
2354 for (omp_context
*octx
= ctx
; octx
!= NULL
; octx
= octx
->outer
)
2355 if (is_gimple_omp (octx
->stmt
)
2356 && is_gimple_omp_oacc (octx
->stmt
))
2358 error_at (gimple_location (stmt
),
2359 "non-OpenACC construct inside of OpenACC region");
2366 if (gimple_code (ctx
->stmt
) == GIMPLE_OMP_FOR
2367 && gimple_omp_for_kind (ctx
->stmt
) & GF_OMP_FOR_SIMD
)
2370 if (gimple_code (stmt
) == GIMPLE_OMP_ORDERED
)
2372 c
= gimple_omp_ordered_clauses (as_a
<gomp_ordered
*> (stmt
));
2373 if (omp_find_clause (c
, OMP_CLAUSE_SIMD
))
2375 if (omp_find_clause (c
, OMP_CLAUSE_THREADS
)
2376 && (ctx
->outer
== NULL
2377 || !gimple_omp_for_combined_into_p (ctx
->stmt
)
2378 || gimple_code (ctx
->outer
->stmt
) != GIMPLE_OMP_FOR
2379 || (gimple_omp_for_kind (ctx
->outer
->stmt
)
2380 != GF_OMP_FOR_KIND_FOR
)
2381 || !gimple_omp_for_combined_p (ctx
->outer
->stmt
)))
2383 error_at (gimple_location (stmt
),
2384 "%<ordered simd threads%> must be closely "
2385 "nested inside of %<for simd%> region");
2391 error_at (gimple_location (stmt
),
2392 "OpenMP constructs other than %<#pragma omp ordered simd%>"
2393 " may not be nested inside %<simd%> region");
2396 else if (gimple_code (ctx
->stmt
) == GIMPLE_OMP_TEAMS
)
2398 if ((gimple_code (stmt
) != GIMPLE_OMP_FOR
2399 || ((gimple_omp_for_kind (stmt
) != GF_OMP_FOR_KIND_DISTRIBUTE
)
2400 && (gimple_omp_for_kind (stmt
) != GF_OMP_FOR_KIND_GRID_LOOP
)))
2401 && gimple_code (stmt
) != GIMPLE_OMP_PARALLEL
)
2403 error_at (gimple_location (stmt
),
2404 "only %<distribute%> or %<parallel%> regions are "
2405 "allowed to be strictly nested inside %<teams%> "
2411 switch (gimple_code (stmt
))
2413 case GIMPLE_OMP_FOR
:
2414 if (gimple_omp_for_kind (stmt
) & GF_OMP_FOR_SIMD
)
2416 if (gimple_omp_for_kind (stmt
) == GF_OMP_FOR_KIND_DISTRIBUTE
)
2418 if (ctx
!= NULL
&& gimple_code (ctx
->stmt
) != GIMPLE_OMP_TEAMS
)
2420 error_at (gimple_location (stmt
),
2421 "%<distribute%> region must be strictly nested "
2422 "inside %<teams%> construct");
2427 /* We split taskloop into task and nested taskloop in it. */
2428 if (gimple_omp_for_kind (stmt
) == GF_OMP_FOR_KIND_TASKLOOP
)
2430 if (gimple_omp_for_kind (stmt
) == GF_OMP_FOR_KIND_OACC_LOOP
)
2435 switch (gimple_code (ctx
->stmt
))
2437 case GIMPLE_OMP_FOR
:
2438 ok
= (gimple_omp_for_kind (ctx
->stmt
)
2439 == GF_OMP_FOR_KIND_OACC_LOOP
);
2442 case GIMPLE_OMP_TARGET
:
2443 switch (gimple_omp_target_kind (ctx
->stmt
))
2445 case GF_OMP_TARGET_KIND_OACC_PARALLEL
:
2446 case GF_OMP_TARGET_KIND_OACC_KERNELS
:
2457 else if (oacc_get_fn_attrib (current_function_decl
))
2461 error_at (gimple_location (stmt
),
2462 "OpenACC loop directive must be associated with"
2463 " an OpenACC compute region");
2469 if (is_gimple_call (stmt
)
2470 && (DECL_FUNCTION_CODE (gimple_call_fndecl (stmt
))
2471 == BUILT_IN_GOMP_CANCEL
2472 || DECL_FUNCTION_CODE (gimple_call_fndecl (stmt
))
2473 == BUILT_IN_GOMP_CANCELLATION_POINT
))
2475 const char *bad
= NULL
;
2476 const char *kind
= NULL
;
2477 const char *construct
2478 = (DECL_FUNCTION_CODE (gimple_call_fndecl (stmt
))
2479 == BUILT_IN_GOMP_CANCEL
)
2480 ? "#pragma omp cancel"
2481 : "#pragma omp cancellation point";
2484 error_at (gimple_location (stmt
), "orphaned %qs construct",
2488 switch (tree_fits_shwi_p (gimple_call_arg (stmt
, 0))
2489 ? tree_to_shwi (gimple_call_arg (stmt
, 0))
2493 if (gimple_code (ctx
->stmt
) != GIMPLE_OMP_PARALLEL
)
2494 bad
= "#pragma omp parallel";
2495 else if (DECL_FUNCTION_CODE (gimple_call_fndecl (stmt
))
2496 == BUILT_IN_GOMP_CANCEL
2497 && !integer_zerop (gimple_call_arg (stmt
, 1)))
2498 ctx
->cancellable
= true;
2502 if (gimple_code (ctx
->stmt
) != GIMPLE_OMP_FOR
2503 || gimple_omp_for_kind (ctx
->stmt
) != GF_OMP_FOR_KIND_FOR
)
2504 bad
= "#pragma omp for";
2505 else if (DECL_FUNCTION_CODE (gimple_call_fndecl (stmt
))
2506 == BUILT_IN_GOMP_CANCEL
2507 && !integer_zerop (gimple_call_arg (stmt
, 1)))
2509 ctx
->cancellable
= true;
2510 if (omp_find_clause (gimple_omp_for_clauses (ctx
->stmt
),
2512 warning_at (gimple_location (stmt
), 0,
2513 "%<#pragma omp cancel for%> inside "
2514 "%<nowait%> for construct");
2515 if (omp_find_clause (gimple_omp_for_clauses (ctx
->stmt
),
2516 OMP_CLAUSE_ORDERED
))
2517 warning_at (gimple_location (stmt
), 0,
2518 "%<#pragma omp cancel for%> inside "
2519 "%<ordered%> for construct");
2524 if (gimple_code (ctx
->stmt
) != GIMPLE_OMP_SECTIONS
2525 && gimple_code (ctx
->stmt
) != GIMPLE_OMP_SECTION
)
2526 bad
= "#pragma omp sections";
2527 else if (DECL_FUNCTION_CODE (gimple_call_fndecl (stmt
))
2528 == BUILT_IN_GOMP_CANCEL
2529 && !integer_zerop (gimple_call_arg (stmt
, 1)))
2531 if (gimple_code (ctx
->stmt
) == GIMPLE_OMP_SECTIONS
)
2533 ctx
->cancellable
= true;
2534 if (omp_find_clause (gimple_omp_sections_clauses
2537 warning_at (gimple_location (stmt
), 0,
2538 "%<#pragma omp cancel sections%> inside "
2539 "%<nowait%> sections construct");
2543 gcc_assert (ctx
->outer
2544 && gimple_code (ctx
->outer
->stmt
)
2545 == GIMPLE_OMP_SECTIONS
);
2546 ctx
->outer
->cancellable
= true;
2547 if (omp_find_clause (gimple_omp_sections_clauses
2550 warning_at (gimple_location (stmt
), 0,
2551 "%<#pragma omp cancel sections%> inside "
2552 "%<nowait%> sections construct");
2558 if (gimple_code (ctx
->stmt
) != GIMPLE_OMP_TASK
)
2559 bad
= "#pragma omp task";
2562 for (omp_context
*octx
= ctx
->outer
;
2563 octx
; octx
= octx
->outer
)
2565 switch (gimple_code (octx
->stmt
))
2567 case GIMPLE_OMP_TASKGROUP
:
2569 case GIMPLE_OMP_TARGET
:
2570 if (gimple_omp_target_kind (octx
->stmt
)
2571 != GF_OMP_TARGET_KIND_REGION
)
2574 case GIMPLE_OMP_PARALLEL
:
2575 case GIMPLE_OMP_TEAMS
:
2576 error_at (gimple_location (stmt
),
2577 "%<%s taskgroup%> construct not closely "
2578 "nested inside of %<taskgroup%> region",
2586 ctx
->cancellable
= true;
2591 error_at (gimple_location (stmt
), "invalid arguments");
2596 error_at (gimple_location (stmt
),
2597 "%<%s %s%> construct not closely nested inside of %qs",
2598 construct
, kind
, bad
);
2603 case GIMPLE_OMP_SECTIONS
:
2604 case GIMPLE_OMP_SINGLE
:
2605 for (; ctx
!= NULL
; ctx
= ctx
->outer
)
2606 switch (gimple_code (ctx
->stmt
))
2608 case GIMPLE_OMP_FOR
:
2609 if (gimple_omp_for_kind (ctx
->stmt
) != GF_OMP_FOR_KIND_FOR
2610 && gimple_omp_for_kind (ctx
->stmt
) != GF_OMP_FOR_KIND_TASKLOOP
)
2613 case GIMPLE_OMP_SECTIONS
:
2614 case GIMPLE_OMP_SINGLE
:
2615 case GIMPLE_OMP_ORDERED
:
2616 case GIMPLE_OMP_MASTER
:
2617 case GIMPLE_OMP_TASK
:
2618 case GIMPLE_OMP_CRITICAL
:
2619 if (is_gimple_call (stmt
))
2621 if (DECL_FUNCTION_CODE (gimple_call_fndecl (stmt
))
2622 != BUILT_IN_GOMP_BARRIER
)
2624 error_at (gimple_location (stmt
),
2625 "barrier region may not be closely nested inside "
2626 "of work-sharing, %<critical%>, %<ordered%>, "
2627 "%<master%>, explicit %<task%> or %<taskloop%> "
2631 error_at (gimple_location (stmt
),
2632 "work-sharing region may not be closely nested inside "
2633 "of work-sharing, %<critical%>, %<ordered%>, "
2634 "%<master%>, explicit %<task%> or %<taskloop%> region");
2636 case GIMPLE_OMP_PARALLEL
:
2637 case GIMPLE_OMP_TEAMS
:
2639 case GIMPLE_OMP_TARGET
:
2640 if (gimple_omp_target_kind (ctx
->stmt
)
2641 == GF_OMP_TARGET_KIND_REGION
)
2648 case GIMPLE_OMP_MASTER
:
2649 for (; ctx
!= NULL
; ctx
= ctx
->outer
)
2650 switch (gimple_code (ctx
->stmt
))
2652 case GIMPLE_OMP_FOR
:
2653 if (gimple_omp_for_kind (ctx
->stmt
) != GF_OMP_FOR_KIND_FOR
2654 && gimple_omp_for_kind (ctx
->stmt
) != GF_OMP_FOR_KIND_TASKLOOP
)
2657 case GIMPLE_OMP_SECTIONS
:
2658 case GIMPLE_OMP_SINGLE
:
2659 case GIMPLE_OMP_TASK
:
2660 error_at (gimple_location (stmt
),
2661 "%<master%> region may not be closely nested inside "
2662 "of work-sharing, explicit %<task%> or %<taskloop%> "
2665 case GIMPLE_OMP_PARALLEL
:
2666 case GIMPLE_OMP_TEAMS
:
2668 case GIMPLE_OMP_TARGET
:
2669 if (gimple_omp_target_kind (ctx
->stmt
)
2670 == GF_OMP_TARGET_KIND_REGION
)
2677 case GIMPLE_OMP_TASK
:
2678 for (c
= gimple_omp_task_clauses (stmt
); c
; c
= OMP_CLAUSE_CHAIN (c
))
2679 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_DEPEND
2680 && (OMP_CLAUSE_DEPEND_KIND (c
) == OMP_CLAUSE_DEPEND_SOURCE
2681 || OMP_CLAUSE_DEPEND_KIND (c
) == OMP_CLAUSE_DEPEND_SINK
))
2683 enum omp_clause_depend_kind kind
= OMP_CLAUSE_DEPEND_KIND (c
);
2684 error_at (OMP_CLAUSE_LOCATION (c
),
2685 "%<depend(%s)%> is only allowed in %<omp ordered%>",
2686 kind
== OMP_CLAUSE_DEPEND_SOURCE
? "source" : "sink");
2690 case GIMPLE_OMP_ORDERED
:
2691 for (c
= gimple_omp_ordered_clauses (as_a
<gomp_ordered
*> (stmt
));
2692 c
; c
= OMP_CLAUSE_CHAIN (c
))
2694 if (OMP_CLAUSE_CODE (c
) != OMP_CLAUSE_DEPEND
)
2696 gcc_assert (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_THREADS
2697 || OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_SIMD
);
2700 enum omp_clause_depend_kind kind
= OMP_CLAUSE_DEPEND_KIND (c
);
2701 if (kind
== OMP_CLAUSE_DEPEND_SOURCE
2702 || kind
== OMP_CLAUSE_DEPEND_SINK
)
2705 /* Look for containing ordered(N) loop. */
2707 || gimple_code (ctx
->stmt
) != GIMPLE_OMP_FOR
2709 = omp_find_clause (gimple_omp_for_clauses (ctx
->stmt
),
2710 OMP_CLAUSE_ORDERED
)) == NULL_TREE
)
2712 error_at (OMP_CLAUSE_LOCATION (c
),
2713 "%<ordered%> construct with %<depend%> clause "
2714 "must be closely nested inside an %<ordered%> "
2718 else if (OMP_CLAUSE_ORDERED_EXPR (oclause
) == NULL_TREE
)
2720 error_at (OMP_CLAUSE_LOCATION (c
),
2721 "%<ordered%> construct with %<depend%> clause "
2722 "must be closely nested inside a loop with "
2723 "%<ordered%> clause with a parameter");
2729 error_at (OMP_CLAUSE_LOCATION (c
),
2730 "invalid depend kind in omp %<ordered%> %<depend%>");
2734 c
= gimple_omp_ordered_clauses (as_a
<gomp_ordered
*> (stmt
));
2735 if (omp_find_clause (c
, OMP_CLAUSE_SIMD
))
2737 /* ordered simd must be closely nested inside of simd region,
2738 and simd region must not encounter constructs other than
2739 ordered simd, therefore ordered simd may be either orphaned,
2740 or ctx->stmt must be simd. The latter case is handled already
2744 error_at (gimple_location (stmt
),
2745 "%<ordered%> %<simd%> must be closely nested inside "
2750 for (; ctx
!= NULL
; ctx
= ctx
->outer
)
2751 switch (gimple_code (ctx
->stmt
))
2753 case GIMPLE_OMP_CRITICAL
:
2754 case GIMPLE_OMP_TASK
:
2755 case GIMPLE_OMP_ORDERED
:
2756 ordered_in_taskloop
:
2757 error_at (gimple_location (stmt
),
2758 "%<ordered%> region may not be closely nested inside "
2759 "of %<critical%>, %<ordered%>, explicit %<task%> or "
2760 "%<taskloop%> region");
2762 case GIMPLE_OMP_FOR
:
2763 if (gimple_omp_for_kind (ctx
->stmt
) == GF_OMP_FOR_KIND_TASKLOOP
)
2764 goto ordered_in_taskloop
;
2766 o
= omp_find_clause (gimple_omp_for_clauses (ctx
->stmt
),
2767 OMP_CLAUSE_ORDERED
);
2770 error_at (gimple_location (stmt
),
2771 "%<ordered%> region must be closely nested inside "
2772 "a loop region with an %<ordered%> clause");
2775 if (OMP_CLAUSE_ORDERED_EXPR (o
) != NULL_TREE
2776 && omp_find_clause (c
, OMP_CLAUSE_DEPEND
) == NULL_TREE
)
2778 error_at (gimple_location (stmt
),
2779 "%<ordered%> region without %<depend%> clause may "
2780 "not be closely nested inside a loop region with "
2781 "an %<ordered%> clause with a parameter");
2785 case GIMPLE_OMP_TARGET
:
2786 if (gimple_omp_target_kind (ctx
->stmt
)
2787 != GF_OMP_TARGET_KIND_REGION
)
2790 case GIMPLE_OMP_PARALLEL
:
2791 case GIMPLE_OMP_TEAMS
:
2792 error_at (gimple_location (stmt
),
2793 "%<ordered%> region must be closely nested inside "
2794 "a loop region with an %<ordered%> clause");
2800 case GIMPLE_OMP_CRITICAL
:
2803 = gimple_omp_critical_name (as_a
<gomp_critical
*> (stmt
));
2804 for (; ctx
!= NULL
; ctx
= ctx
->outer
)
2805 if (gomp_critical
*other_crit
2806 = dyn_cast
<gomp_critical
*> (ctx
->stmt
))
2807 if (this_stmt_name
== gimple_omp_critical_name (other_crit
))
2809 error_at (gimple_location (stmt
),
2810 "%<critical%> region may not be nested inside "
2811 "a %<critical%> region with the same name");
2816 case GIMPLE_OMP_TEAMS
:
2818 || gimple_code (ctx
->stmt
) != GIMPLE_OMP_TARGET
2819 || gimple_omp_target_kind (ctx
->stmt
) != GF_OMP_TARGET_KIND_REGION
)
2821 error_at (gimple_location (stmt
),
2822 "%<teams%> construct not closely nested inside of "
2823 "%<target%> construct");
2827 case GIMPLE_OMP_TARGET
:
2828 for (c
= gimple_omp_target_clauses (stmt
); c
; c
= OMP_CLAUSE_CHAIN (c
))
2829 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_DEPEND
2830 && (OMP_CLAUSE_DEPEND_KIND (c
) == OMP_CLAUSE_DEPEND_SOURCE
2831 || OMP_CLAUSE_DEPEND_KIND (c
) == OMP_CLAUSE_DEPEND_SINK
))
2833 enum omp_clause_depend_kind kind
= OMP_CLAUSE_DEPEND_KIND (c
);
2834 error_at (OMP_CLAUSE_LOCATION (c
),
2835 "%<depend(%s)%> is only allowed in %<omp ordered%>",
2836 kind
== OMP_CLAUSE_DEPEND_SOURCE
? "source" : "sink");
2839 if (is_gimple_omp_offloaded (stmt
)
2840 && oacc_get_fn_attrib (cfun
->decl
) != NULL
)
2842 error_at (gimple_location (stmt
),
2843 "OpenACC region inside of OpenACC routine, nested "
2844 "parallelism not supported yet");
2847 for (; ctx
!= NULL
; ctx
= ctx
->outer
)
2849 if (gimple_code (ctx
->stmt
) != GIMPLE_OMP_TARGET
)
2851 if (is_gimple_omp (stmt
)
2852 && is_gimple_omp_oacc (stmt
)
2853 && is_gimple_omp (ctx
->stmt
))
2855 error_at (gimple_location (stmt
),
2856 "OpenACC construct inside of non-OpenACC region");
2862 const char *stmt_name
, *ctx_stmt_name
;
2863 switch (gimple_omp_target_kind (stmt
))
2865 case GF_OMP_TARGET_KIND_REGION
: stmt_name
= "target"; break;
2866 case GF_OMP_TARGET_KIND_DATA
: stmt_name
= "target data"; break;
2867 case GF_OMP_TARGET_KIND_UPDATE
: stmt_name
= "target update"; break;
2868 case GF_OMP_TARGET_KIND_ENTER_DATA
:
2869 stmt_name
= "target enter data"; break;
2870 case GF_OMP_TARGET_KIND_EXIT_DATA
:
2871 stmt_name
= "target exit data"; break;
2872 case GF_OMP_TARGET_KIND_OACC_PARALLEL
: stmt_name
= "parallel"; break;
2873 case GF_OMP_TARGET_KIND_OACC_KERNELS
: stmt_name
= "kernels"; break;
2874 case GF_OMP_TARGET_KIND_OACC_DATA
: stmt_name
= "data"; break;
2875 case GF_OMP_TARGET_KIND_OACC_UPDATE
: stmt_name
= "update"; break;
2876 case GF_OMP_TARGET_KIND_OACC_ENTER_EXIT_DATA
:
2877 stmt_name
= "enter/exit data"; break;
2878 case GF_OMP_TARGET_KIND_OACC_HOST_DATA
: stmt_name
= "host_data";
2880 default: gcc_unreachable ();
2882 switch (gimple_omp_target_kind (ctx
->stmt
))
2884 case GF_OMP_TARGET_KIND_REGION
: ctx_stmt_name
= "target"; break;
2885 case GF_OMP_TARGET_KIND_DATA
: ctx_stmt_name
= "target data"; break;
2886 case GF_OMP_TARGET_KIND_OACC_PARALLEL
:
2887 ctx_stmt_name
= "parallel"; break;
2888 case GF_OMP_TARGET_KIND_OACC_KERNELS
:
2889 ctx_stmt_name
= "kernels"; break;
2890 case GF_OMP_TARGET_KIND_OACC_DATA
: ctx_stmt_name
= "data"; break;
2891 case GF_OMP_TARGET_KIND_OACC_HOST_DATA
:
2892 ctx_stmt_name
= "host_data"; break;
2893 default: gcc_unreachable ();
2896 /* OpenACC/OpenMP mismatch? */
2897 if (is_gimple_omp_oacc (stmt
)
2898 != is_gimple_omp_oacc (ctx
->stmt
))
2900 error_at (gimple_location (stmt
),
2901 "%s %qs construct inside of %s %qs region",
2902 (is_gimple_omp_oacc (stmt
)
2903 ? "OpenACC" : "OpenMP"), stmt_name
,
2904 (is_gimple_omp_oacc (ctx
->stmt
)
2905 ? "OpenACC" : "OpenMP"), ctx_stmt_name
);
2908 if (is_gimple_omp_offloaded (ctx
->stmt
))
2910 /* No GIMPLE_OMP_TARGET inside offloaded OpenACC CTX. */
2911 if (is_gimple_omp_oacc (ctx
->stmt
))
2913 error_at (gimple_location (stmt
),
2914 "%qs construct inside of %qs region",
2915 stmt_name
, ctx_stmt_name
);
2920 warning_at (gimple_location (stmt
), 0,
2921 "%qs construct inside of %qs region",
2922 stmt_name
, ctx_stmt_name
);
2934 /* Helper function scan_omp.
2936 Callback for walk_tree or operators in walk_gimple_stmt used to
2937 scan for OMP directives in TP. */
2940 scan_omp_1_op (tree
*tp
, int *walk_subtrees
, void *data
)
2942 struct walk_stmt_info
*wi
= (struct walk_stmt_info
*) data
;
2943 omp_context
*ctx
= (omp_context
*) wi
->info
;
2946 switch (TREE_CODE (t
))
2954 tree repl
= remap_decl (t
, &ctx
->cb
);
2955 gcc_checking_assert (TREE_CODE (repl
) != ERROR_MARK
);
2961 if (ctx
&& TYPE_P (t
))
2962 *tp
= remap_type (t
, &ctx
->cb
);
2963 else if (!DECL_P (t
))
2968 tree tem
= remap_type (TREE_TYPE (t
), &ctx
->cb
);
2969 if (tem
!= TREE_TYPE (t
))
2971 if (TREE_CODE (t
) == INTEGER_CST
)
2972 *tp
= wide_int_to_tree (tem
, wi::to_wide (t
));
2974 TREE_TYPE (t
) = tem
;
2984 /* Return true if FNDECL is a setjmp or a longjmp. */
2987 setjmp_or_longjmp_p (const_tree fndecl
)
2989 if (fndecl_built_in_p (fndecl
, BUILT_IN_SETJMP
)
2990 || fndecl_built_in_p (fndecl
, BUILT_IN_LONGJMP
))
2993 tree declname
= DECL_NAME (fndecl
);
2996 const char *name
= IDENTIFIER_POINTER (declname
);
2997 return !strcmp (name
, "setjmp") || !strcmp (name
, "longjmp");
3001 /* Helper function for scan_omp.
3003 Callback for walk_gimple_stmt used to scan for OMP directives in
3004 the current statement in GSI. */
3007 scan_omp_1_stmt (gimple_stmt_iterator
*gsi
, bool *handled_ops_p
,
3008 struct walk_stmt_info
*wi
)
3010 gimple
*stmt
= gsi_stmt (*gsi
);
3011 omp_context
*ctx
= (omp_context
*) wi
->info
;
3013 if (gimple_has_location (stmt
))
3014 input_location
= gimple_location (stmt
);
3016 /* Check the nesting restrictions. */
3017 bool remove
= false;
3018 if (is_gimple_omp (stmt
))
3019 remove
= !check_omp_nesting_restrictions (stmt
, ctx
);
3020 else if (is_gimple_call (stmt
))
3022 tree fndecl
= gimple_call_fndecl (stmt
);
3025 if (setjmp_or_longjmp_p (fndecl
)
3027 && gimple_code (ctx
->stmt
) == GIMPLE_OMP_FOR
3028 && gimple_omp_for_kind (ctx
->stmt
) & GF_OMP_FOR_SIMD
)
3031 error_at (gimple_location (stmt
),
3032 "setjmp/longjmp inside simd construct");
3034 else if (DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_NORMAL
)
3035 switch (DECL_FUNCTION_CODE (fndecl
))
3037 case BUILT_IN_GOMP_BARRIER
:
3038 case BUILT_IN_GOMP_CANCEL
:
3039 case BUILT_IN_GOMP_CANCELLATION_POINT
:
3040 case BUILT_IN_GOMP_TASKYIELD
:
3041 case BUILT_IN_GOMP_TASKWAIT
:
3042 case BUILT_IN_GOMP_TASKGROUP_START
:
3043 case BUILT_IN_GOMP_TASKGROUP_END
:
3044 remove
= !check_omp_nesting_restrictions (stmt
, ctx
);
3053 stmt
= gimple_build_nop ();
3054 gsi_replace (gsi
, stmt
, false);
3057 *handled_ops_p
= true;
3059 switch (gimple_code (stmt
))
3061 case GIMPLE_OMP_PARALLEL
:
3062 taskreg_nesting_level
++;
3063 scan_omp_parallel (gsi
, ctx
);
3064 taskreg_nesting_level
--;
3067 case GIMPLE_OMP_TASK
:
3068 taskreg_nesting_level
++;
3069 scan_omp_task (gsi
, ctx
);
3070 taskreg_nesting_level
--;
3073 case GIMPLE_OMP_FOR
:
3074 if (((gimple_omp_for_kind (as_a
<gomp_for
*> (stmt
))
3075 & GF_OMP_FOR_KIND_MASK
) == GF_OMP_FOR_KIND_SIMD
)
3076 && omp_maybe_offloaded_ctx (ctx
)
3077 && omp_max_simt_vf ())
3078 scan_omp_simd (gsi
, as_a
<gomp_for
*> (stmt
), ctx
);
3080 scan_omp_for (as_a
<gomp_for
*> (stmt
), ctx
);
3083 case GIMPLE_OMP_SECTIONS
:
3084 scan_omp_sections (as_a
<gomp_sections
*> (stmt
), ctx
);
3087 case GIMPLE_OMP_SINGLE
:
3088 scan_omp_single (as_a
<gomp_single
*> (stmt
), ctx
);
3091 case GIMPLE_OMP_SECTION
:
3092 case GIMPLE_OMP_MASTER
:
3093 case GIMPLE_OMP_TASKGROUP
:
3094 case GIMPLE_OMP_ORDERED
:
3095 case GIMPLE_OMP_CRITICAL
:
3096 case GIMPLE_OMP_GRID_BODY
:
3097 ctx
= new_omp_context (stmt
, ctx
);
3098 scan_omp (gimple_omp_body_ptr (stmt
), ctx
);
3101 case GIMPLE_OMP_TARGET
:
3102 scan_omp_target (as_a
<gomp_target
*> (stmt
), ctx
);
3105 case GIMPLE_OMP_TEAMS
:
3106 scan_omp_teams (as_a
<gomp_teams
*> (stmt
), ctx
);
3113 *handled_ops_p
= false;
3115 for (var
= gimple_bind_vars (as_a
<gbind
*> (stmt
));
3117 var
= DECL_CHAIN (var
))
3118 insert_decl_map (&ctx
->cb
, var
, var
);
3122 *handled_ops_p
= false;
3130 /* Scan all the statements starting at the current statement. CTX
3131 contains context information about the OMP directives and
3132 clauses found during the scan. */
3135 scan_omp (gimple_seq
*body_p
, omp_context
*ctx
)
3137 location_t saved_location
;
3138 struct walk_stmt_info wi
;
3140 memset (&wi
, 0, sizeof (wi
));
3142 wi
.want_locations
= true;
3144 saved_location
= input_location
;
3145 walk_gimple_seq_mod (body_p
, scan_omp_1_stmt
, scan_omp_1_op
, &wi
);
3146 input_location
= saved_location
;
3149 /* Re-gimplification and code generation routines. */
3151 /* Remove omp_member_access_dummy_var variables from gimple_bind_vars
3152 of BIND if in a method. */
3155 maybe_remove_omp_member_access_dummy_vars (gbind
*bind
)
3157 if (DECL_ARGUMENTS (current_function_decl
)
3158 && DECL_ARTIFICIAL (DECL_ARGUMENTS (current_function_decl
))
3159 && (TREE_CODE (TREE_TYPE (DECL_ARGUMENTS (current_function_decl
)))
3162 tree vars
= gimple_bind_vars (bind
);
3163 for (tree
*pvar
= &vars
; *pvar
; )
3164 if (omp_member_access_dummy_var (*pvar
))
3165 *pvar
= DECL_CHAIN (*pvar
);
3167 pvar
= &DECL_CHAIN (*pvar
);
3168 gimple_bind_set_vars (bind
, vars
);
3172 /* Remove omp_member_access_dummy_var variables from BLOCK_VARS of
3173 block and its subblocks. */
3176 remove_member_access_dummy_vars (tree block
)
3178 for (tree
*pvar
= &BLOCK_VARS (block
); *pvar
; )
3179 if (omp_member_access_dummy_var (*pvar
))
3180 *pvar
= DECL_CHAIN (*pvar
);
3182 pvar
= &DECL_CHAIN (*pvar
);
3184 for (block
= BLOCK_SUBBLOCKS (block
); block
; block
= BLOCK_CHAIN (block
))
3185 remove_member_access_dummy_vars (block
);
3188 /* If a context was created for STMT when it was scanned, return it. */
3190 static omp_context
*
3191 maybe_lookup_ctx (gimple
*stmt
)
3194 n
= splay_tree_lookup (all_contexts
, (splay_tree_key
) stmt
);
3195 return n
? (omp_context
*) n
->value
: NULL
;
3199 /* Find the mapping for DECL in CTX or the immediately enclosing
3200 context that has a mapping for DECL.
3202 If CTX is a nested parallel directive, we may have to use the decl
3203 mappings created in CTX's parent context. Suppose that we have the
3204 following parallel nesting (variable UIDs showed for clarity):
3207 #omp parallel shared(iD.1562) -> outer parallel
3208 iD.1562 = iD.1562 + 1;
3210 #omp parallel shared (iD.1562) -> inner parallel
3211 iD.1562 = iD.1562 - 1;
3213 Each parallel structure will create a distinct .omp_data_s structure
3214 for copying iD.1562 in/out of the directive:
3216 outer parallel .omp_data_s.1.i -> iD.1562
3217 inner parallel .omp_data_s.2.i -> iD.1562
3219 A shared variable mapping will produce a copy-out operation before
3220 the parallel directive and a copy-in operation after it. So, in
3221 this case we would have:
3224 .omp_data_o.1.i = iD.1562;
3225 #omp parallel shared(iD.1562) -> outer parallel
3226 .omp_data_i.1 = &.omp_data_o.1
3227 .omp_data_i.1->i = .omp_data_i.1->i + 1;
3229 .omp_data_o.2.i = iD.1562; -> **
3230 #omp parallel shared(iD.1562) -> inner parallel
3231 .omp_data_i.2 = &.omp_data_o.2
3232 .omp_data_i.2->i = .omp_data_i.2->i - 1;
3235 ** This is a problem. The symbol iD.1562 cannot be referenced
3236 inside the body of the outer parallel region. But since we are
3237 emitting this copy operation while expanding the inner parallel
3238 directive, we need to access the CTX structure of the outer
3239 parallel directive to get the correct mapping:
3241 .omp_data_o.2.i = .omp_data_i.1->i
3243 Since there may be other workshare or parallel directives enclosing
3244 the parallel directive, it may be necessary to walk up the context
3245 parent chain. This is not a problem in general because nested
3246 parallelism happens only rarely. */
3249 lookup_decl_in_outer_ctx (tree decl
, omp_context
*ctx
)
3254 for (up
= ctx
->outer
, t
= NULL
; up
&& t
== NULL
; up
= up
->outer
)
3255 t
= maybe_lookup_decl (decl
, up
);
3257 gcc_assert (!ctx
->is_nested
|| t
|| is_global_var (decl
));
3259 return t
? t
: decl
;
3263 /* Similar to lookup_decl_in_outer_ctx, but return DECL if not found
3264 in outer contexts. */
3267 maybe_lookup_decl_in_outer_ctx (tree decl
, omp_context
*ctx
)
3272 for (up
= ctx
->outer
, t
= NULL
; up
&& t
== NULL
; up
= up
->outer
)
3273 t
= maybe_lookup_decl (decl
, up
);
3275 return t
? t
: decl
;
3279 /* Construct the initialization value for reduction operation OP. */
3282 omp_reduction_init_op (location_t loc
, enum tree_code op
, tree type
)
3291 case TRUTH_ORIF_EXPR
:
3292 case TRUTH_XOR_EXPR
:
3294 return build_zero_cst (type
);
3297 case TRUTH_AND_EXPR
:
3298 case TRUTH_ANDIF_EXPR
:
3300 return fold_convert_loc (loc
, type
, integer_one_node
);
3303 return fold_convert_loc (loc
, type
, integer_minus_one_node
);
3306 if (SCALAR_FLOAT_TYPE_P (type
))
3308 REAL_VALUE_TYPE max
, min
;
3309 if (HONOR_INFINITIES (type
))
3312 real_arithmetic (&min
, NEGATE_EXPR
, &max
, NULL
);
3315 real_maxval (&min
, 1, TYPE_MODE (type
));
3316 return build_real (type
, min
);
3318 else if (POINTER_TYPE_P (type
))
3321 = wi::min_value (TYPE_PRECISION (type
), TYPE_SIGN (type
));
3322 return wide_int_to_tree (type
, min
);
3326 gcc_assert (INTEGRAL_TYPE_P (type
));
3327 return TYPE_MIN_VALUE (type
);
3331 if (SCALAR_FLOAT_TYPE_P (type
))
3333 REAL_VALUE_TYPE max
;
3334 if (HONOR_INFINITIES (type
))
3337 real_maxval (&max
, 0, TYPE_MODE (type
));
3338 return build_real (type
, max
);
3340 else if (POINTER_TYPE_P (type
))
3343 = wi::max_value (TYPE_PRECISION (type
), TYPE_SIGN (type
));
3344 return wide_int_to_tree (type
, max
);
3348 gcc_assert (INTEGRAL_TYPE_P (type
));
3349 return TYPE_MAX_VALUE (type
);
3357 /* Construct the initialization value for reduction CLAUSE. */
3360 omp_reduction_init (tree clause
, tree type
)
3362 return omp_reduction_init_op (OMP_CLAUSE_LOCATION (clause
),
3363 OMP_CLAUSE_REDUCTION_CODE (clause
), type
);
3366 /* Return alignment to be assumed for var in CLAUSE, which should be
3367 OMP_CLAUSE_ALIGNED. */
3370 omp_clause_aligned_alignment (tree clause
)
3372 if (OMP_CLAUSE_ALIGNED_ALIGNMENT (clause
))
3373 return OMP_CLAUSE_ALIGNED_ALIGNMENT (clause
);
3375 /* Otherwise return implementation defined alignment. */
3376 unsigned int al
= 1;
3377 opt_scalar_mode mode_iter
;
3378 auto_vector_sizes sizes
;
3379 targetm
.vectorize
.autovectorize_vector_sizes (&sizes
);
3381 for (unsigned int i
= 0; i
< sizes
.length (); ++i
)
3382 vs
= ordered_max (vs
, sizes
[i
]);
3383 static enum mode_class classes
[]
3384 = { MODE_INT
, MODE_VECTOR_INT
, MODE_FLOAT
, MODE_VECTOR_FLOAT
};
3385 for (int i
= 0; i
< 4; i
+= 2)
3386 /* The for loop above dictates that we only walk through scalar classes. */
3387 FOR_EACH_MODE_IN_CLASS (mode_iter
, classes
[i
])
3389 scalar_mode mode
= mode_iter
.require ();
3390 machine_mode vmode
= targetm
.vectorize
.preferred_simd_mode (mode
);
3391 if (GET_MODE_CLASS (vmode
) != classes
[i
+ 1])
3393 while (maybe_ne (vs
, 0U)
3394 && known_lt (GET_MODE_SIZE (vmode
), vs
)
3395 && GET_MODE_2XWIDER_MODE (vmode
).exists ())
3396 vmode
= GET_MODE_2XWIDER_MODE (vmode
).require ();
3398 tree type
= lang_hooks
.types
.type_for_mode (mode
, 1);
3399 if (type
== NULL_TREE
|| TYPE_MODE (type
) != mode
)
3401 poly_uint64 nelts
= exact_div (GET_MODE_SIZE (vmode
),
3402 GET_MODE_SIZE (mode
));
3403 type
= build_vector_type (type
, nelts
);
3404 if (TYPE_MODE (type
) != vmode
)
3406 if (TYPE_ALIGN_UNIT (type
) > al
)
3407 al
= TYPE_ALIGN_UNIT (type
);
3409 return build_int_cst (integer_type_node
, al
);
3413 /* This structure is part of the interface between lower_rec_simd_input_clauses
3414 and lower_rec_input_clauses. */
3416 struct omplow_simd_context
{
3417 omplow_simd_context () { memset (this, 0, sizeof (*this)); }
3420 vec
<tree
, va_heap
> simt_eargs
;
3421 gimple_seq simt_dlist
;
3422 poly_uint64_pod max_vf
;
3426 /* Helper function of lower_rec_input_clauses, used for #pragma omp simd
3430 lower_rec_simd_input_clauses (tree new_var
, omp_context
*ctx
,
3431 omplow_simd_context
*sctx
, tree
&ivar
, tree
&lvar
)
3433 if (known_eq (sctx
->max_vf
, 0U))
3435 sctx
->max_vf
= sctx
->is_simt
? omp_max_simt_vf () : omp_max_vf ();
3436 if (maybe_gt (sctx
->max_vf
, 1U))
3438 tree c
= omp_find_clause (gimple_omp_for_clauses (ctx
->stmt
),
3439 OMP_CLAUSE_SAFELEN
);
3442 poly_uint64 safe_len
;
3443 if (!poly_int_tree_p (OMP_CLAUSE_SAFELEN_EXPR (c
), &safe_len
)
3444 || maybe_lt (safe_len
, 1U))
3447 sctx
->max_vf
= lower_bound (sctx
->max_vf
, safe_len
);
3450 if (maybe_gt (sctx
->max_vf
, 1U))
3452 sctx
->idx
= create_tmp_var (unsigned_type_node
);
3453 sctx
->lane
= create_tmp_var (unsigned_type_node
);
3456 if (known_eq (sctx
->max_vf
, 1U))
3461 if (is_gimple_reg (new_var
))
3463 ivar
= lvar
= new_var
;
3466 tree type
= TREE_TYPE (new_var
), ptype
= build_pointer_type (type
);
3467 ivar
= lvar
= create_tmp_var (type
);
3468 TREE_ADDRESSABLE (ivar
) = 1;
3469 DECL_ATTRIBUTES (ivar
) = tree_cons (get_identifier ("omp simt private"),
3470 NULL
, DECL_ATTRIBUTES (ivar
));
3471 sctx
->simt_eargs
.safe_push (build1 (ADDR_EXPR
, ptype
, ivar
));
3472 tree clobber
= build_constructor (type
, NULL
);
3473 TREE_THIS_VOLATILE (clobber
) = 1;
3474 gimple
*g
= gimple_build_assign (ivar
, clobber
);
3475 gimple_seq_add_stmt (&sctx
->simt_dlist
, g
);
3479 tree atype
= build_array_type_nelts (TREE_TYPE (new_var
), sctx
->max_vf
);
3480 tree avar
= create_tmp_var_raw (atype
);
3481 if (TREE_ADDRESSABLE (new_var
))
3482 TREE_ADDRESSABLE (avar
) = 1;
3483 DECL_ATTRIBUTES (avar
)
3484 = tree_cons (get_identifier ("omp simd array"), NULL
,
3485 DECL_ATTRIBUTES (avar
));
3486 gimple_add_tmp_var (avar
);
3487 ivar
= build4 (ARRAY_REF
, TREE_TYPE (new_var
), avar
, sctx
->idx
,
3488 NULL_TREE
, NULL_TREE
);
3489 lvar
= build4 (ARRAY_REF
, TREE_TYPE (new_var
), avar
, sctx
->lane
,
3490 NULL_TREE
, NULL_TREE
);
3492 if (DECL_P (new_var
))
3494 SET_DECL_VALUE_EXPR (new_var
, lvar
);
3495 DECL_HAS_VALUE_EXPR_P (new_var
) = 1;
3500 /* Helper function of lower_rec_input_clauses. For a reference
3501 in simd reduction, add an underlying variable it will reference. */
3504 handle_simd_reference (location_t loc
, tree new_vard
, gimple_seq
*ilist
)
3506 tree z
= TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (new_vard
)));
3507 if (TREE_CONSTANT (z
))
3509 z
= create_tmp_var_raw (TREE_TYPE (TREE_TYPE (new_vard
)),
3510 get_name (new_vard
));
3511 gimple_add_tmp_var (z
);
3512 TREE_ADDRESSABLE (z
) = 1;
3513 z
= build_fold_addr_expr_loc (loc
, z
);
3514 gimplify_assign (new_vard
, z
, ilist
);
3518 /* Generate code to implement the input clauses, FIRSTPRIVATE and COPYIN,
3519 from the receiver (aka child) side and initializers for REFERENCE_TYPE
3520 private variables. Initialization statements go in ILIST, while calls
3521 to destructors go in DLIST. */
3524 lower_rec_input_clauses (tree clauses
, gimple_seq
*ilist
, gimple_seq
*dlist
,
3525 omp_context
*ctx
, struct omp_for_data
*fd
)
3527 tree c
, dtor
, copyin_seq
, x
, ptr
;
3528 bool copyin_by_ref
= false;
3529 bool lastprivate_firstprivate
= false;
3530 bool reduction_omp_orig_ref
= false;
3532 bool is_simd
= (gimple_code (ctx
->stmt
) == GIMPLE_OMP_FOR
3533 && gimple_omp_for_kind (ctx
->stmt
) & GF_OMP_FOR_SIMD
);
3534 omplow_simd_context sctx
= omplow_simd_context ();
3535 tree simt_lane
= NULL_TREE
, simtrec
= NULL_TREE
;
3536 tree ivar
= NULL_TREE
, lvar
= NULL_TREE
, uid
= NULL_TREE
;
3537 gimple_seq llist
[3] = { };
3540 sctx
.is_simt
= is_simd
&& omp_find_clause (clauses
, OMP_CLAUSE__SIMT_
);
3542 /* Set max_vf=1 (which will later enforce safelen=1) in simd loops
3543 with data sharing clauses referencing variable sized vars. That
3544 is unnecessarily hard to support and very unlikely to result in
3545 vectorized code anyway. */
3547 for (c
= clauses
; c
; c
= OMP_CLAUSE_CHAIN (c
))
3548 switch (OMP_CLAUSE_CODE (c
))
3550 case OMP_CLAUSE_LINEAR
:
3551 if (OMP_CLAUSE_LINEAR_ARRAY (c
))
3554 case OMP_CLAUSE_PRIVATE
:
3555 case OMP_CLAUSE_FIRSTPRIVATE
:
3556 case OMP_CLAUSE_LASTPRIVATE
:
3557 if (is_variable_sized (OMP_CLAUSE_DECL (c
)))
3560 case OMP_CLAUSE_REDUCTION
:
3561 if (TREE_CODE (OMP_CLAUSE_DECL (c
)) == MEM_REF
3562 || is_variable_sized (OMP_CLAUSE_DECL (c
)))
3569 /* Add a placeholder for simduid. */
3570 if (sctx
.is_simt
&& maybe_ne (sctx
.max_vf
, 1U))
3571 sctx
.simt_eargs
.safe_push (NULL_TREE
);
3573 /* Do all the fixed sized types in the first pass, and the variable sized
3574 types in the second pass. This makes sure that the scalar arguments to
3575 the variable sized types are processed before we use them in the
3576 variable sized operations. */
3577 for (pass
= 0; pass
< 2; ++pass
)
3579 for (c
= clauses
; c
; c
= OMP_CLAUSE_CHAIN (c
))
3581 enum omp_clause_code c_kind
= OMP_CLAUSE_CODE (c
);
3584 location_t clause_loc
= OMP_CLAUSE_LOCATION (c
);
3588 case OMP_CLAUSE_PRIVATE
:
3589 if (OMP_CLAUSE_PRIVATE_DEBUG (c
))
3592 case OMP_CLAUSE_SHARED
:
3593 /* Ignore shared directives in teams construct. */
3594 if (gimple_code (ctx
->stmt
) == GIMPLE_OMP_TEAMS
)
3596 if (maybe_lookup_decl (OMP_CLAUSE_DECL (c
), ctx
) == NULL
)
3598 gcc_assert (OMP_CLAUSE_SHARED_FIRSTPRIVATE (c
)
3599 || is_global_var (OMP_CLAUSE_DECL (c
)));
3602 case OMP_CLAUSE_FIRSTPRIVATE
:
3603 case OMP_CLAUSE_COPYIN
:
3605 case OMP_CLAUSE_LINEAR
:
3606 if (!OMP_CLAUSE_LINEAR_NO_COPYIN (c
)
3607 && !OMP_CLAUSE_LINEAR_NO_COPYOUT (c
))
3608 lastprivate_firstprivate
= true;
3610 case OMP_CLAUSE_REDUCTION
:
3611 if (OMP_CLAUSE_REDUCTION_OMP_ORIG_REF (c
))
3612 reduction_omp_orig_ref
= true;
3614 case OMP_CLAUSE__LOOPTEMP_
:
3615 /* Handle _looptemp_ clauses only on parallel/task. */
3619 case OMP_CLAUSE_LASTPRIVATE
:
3620 if (OMP_CLAUSE_LASTPRIVATE_FIRSTPRIVATE (c
))
3622 lastprivate_firstprivate
= true;
3623 if (pass
!= 0 || is_taskloop_ctx (ctx
))
3626 /* Even without corresponding firstprivate, if
3627 decl is Fortran allocatable, it needs outer var
3630 && lang_hooks
.decls
.omp_private_outer_ref
3631 (OMP_CLAUSE_DECL (c
)))
3632 lastprivate_firstprivate
= true;
3634 case OMP_CLAUSE_ALIGNED
:
3637 var
= OMP_CLAUSE_DECL (c
);
3638 if (TREE_CODE (TREE_TYPE (var
)) == POINTER_TYPE
3639 && !is_global_var (var
))
3641 new_var
= maybe_lookup_decl (var
, ctx
);
3642 if (new_var
== NULL_TREE
)
3643 new_var
= maybe_lookup_decl_in_outer_ctx (var
, ctx
);
3644 x
= builtin_decl_explicit (BUILT_IN_ASSUME_ALIGNED
);
3645 tree alarg
= omp_clause_aligned_alignment (c
);
3646 alarg
= fold_convert_loc (clause_loc
, size_type_node
, alarg
);
3647 x
= build_call_expr_loc (clause_loc
, x
, 2, new_var
, alarg
);
3648 x
= fold_convert_loc (clause_loc
, TREE_TYPE (new_var
), x
);
3649 x
= build2 (MODIFY_EXPR
, TREE_TYPE (new_var
), new_var
, x
);
3650 gimplify_and_add (x
, ilist
);
3652 else if (TREE_CODE (TREE_TYPE (var
)) == ARRAY_TYPE
3653 && is_global_var (var
))
3655 tree ptype
= build_pointer_type (TREE_TYPE (var
)), t
, t2
;
3656 new_var
= lookup_decl (var
, ctx
);
3657 t
= maybe_lookup_decl_in_outer_ctx (var
, ctx
);
3658 t
= build_fold_addr_expr_loc (clause_loc
, t
);
3659 t2
= builtin_decl_explicit (BUILT_IN_ASSUME_ALIGNED
);
3660 tree alarg
= omp_clause_aligned_alignment (c
);
3661 alarg
= fold_convert_loc (clause_loc
, size_type_node
, alarg
);
3662 t
= build_call_expr_loc (clause_loc
, t2
, 2, t
, alarg
);
3663 t
= fold_convert_loc (clause_loc
, ptype
, t
);
3664 x
= create_tmp_var (ptype
);
3665 t
= build2 (MODIFY_EXPR
, ptype
, x
, t
);
3666 gimplify_and_add (t
, ilist
);
3667 t
= build_simple_mem_ref_loc (clause_loc
, x
);
3668 SET_DECL_VALUE_EXPR (new_var
, t
);
3669 DECL_HAS_VALUE_EXPR_P (new_var
) = 1;
3676 new_var
= var
= OMP_CLAUSE_DECL (c
);
3677 if (c_kind
== OMP_CLAUSE_REDUCTION
&& TREE_CODE (var
) == MEM_REF
)
3679 var
= TREE_OPERAND (var
, 0);
3680 if (TREE_CODE (var
) == POINTER_PLUS_EXPR
)
3681 var
= TREE_OPERAND (var
, 0);
3682 if (TREE_CODE (var
) == INDIRECT_REF
3683 || TREE_CODE (var
) == ADDR_EXPR
)
3684 var
= TREE_OPERAND (var
, 0);
3685 if (is_variable_sized (var
))
3687 gcc_assert (DECL_HAS_VALUE_EXPR_P (var
));
3688 var
= DECL_VALUE_EXPR (var
);
3689 gcc_assert (TREE_CODE (var
) == INDIRECT_REF
);
3690 var
= TREE_OPERAND (var
, 0);
3691 gcc_assert (DECL_P (var
));
3695 if (c_kind
!= OMP_CLAUSE_COPYIN
)
3696 new_var
= lookup_decl (var
, ctx
);
3698 if (c_kind
== OMP_CLAUSE_SHARED
|| c_kind
== OMP_CLAUSE_COPYIN
)
3703 /* C/C++ array section reductions. */
3704 else if (c_kind
== OMP_CLAUSE_REDUCTION
3705 && var
!= OMP_CLAUSE_DECL (c
))
3710 tree bias
= TREE_OPERAND (OMP_CLAUSE_DECL (c
), 1);
3711 tree orig_var
= TREE_OPERAND (OMP_CLAUSE_DECL (c
), 0);
3712 if (TREE_CODE (orig_var
) == POINTER_PLUS_EXPR
)
3714 tree b
= TREE_OPERAND (orig_var
, 1);
3715 b
= maybe_lookup_decl (b
, ctx
);
3718 b
= TREE_OPERAND (orig_var
, 1);
3719 b
= maybe_lookup_decl_in_outer_ctx (b
, ctx
);
3721 if (integer_zerop (bias
))
3725 bias
= fold_convert_loc (clause_loc
,
3726 TREE_TYPE (b
), bias
);
3727 bias
= fold_build2_loc (clause_loc
, PLUS_EXPR
,
3728 TREE_TYPE (b
), b
, bias
);
3730 orig_var
= TREE_OPERAND (orig_var
, 0);
3732 if (TREE_CODE (orig_var
) == INDIRECT_REF
3733 || TREE_CODE (orig_var
) == ADDR_EXPR
)
3734 orig_var
= TREE_OPERAND (orig_var
, 0);
3735 tree d
= OMP_CLAUSE_DECL (c
);
3736 tree type
= TREE_TYPE (d
);
3737 gcc_assert (TREE_CODE (type
) == ARRAY_TYPE
);
3738 tree v
= TYPE_MAX_VALUE (TYPE_DOMAIN (type
));
3739 const char *name
= get_name (orig_var
);
3740 if (TREE_CONSTANT (v
))
3742 x
= create_tmp_var_raw (type
, name
);
3743 gimple_add_tmp_var (x
);
3744 TREE_ADDRESSABLE (x
) = 1;
3745 x
= build_fold_addr_expr_loc (clause_loc
, x
);
3750 = builtin_decl_explicit (BUILT_IN_ALLOCA_WITH_ALIGN
);
3751 tree t
= maybe_lookup_decl (v
, ctx
);
3755 v
= maybe_lookup_decl_in_outer_ctx (v
, ctx
);
3756 gimplify_expr (&v
, ilist
, NULL
, is_gimple_val
, fb_rvalue
);
3757 t
= fold_build2_loc (clause_loc
, PLUS_EXPR
,
3759 build_int_cst (TREE_TYPE (v
), 1));
3760 t
= fold_build2_loc (clause_loc
, MULT_EXPR
,
3762 TYPE_SIZE_UNIT (TREE_TYPE (type
)));
3763 tree al
= size_int (TYPE_ALIGN (TREE_TYPE (type
)));
3764 x
= build_call_expr_loc (clause_loc
, atmp
, 2, t
, al
);
3767 tree ptype
= build_pointer_type (TREE_TYPE (type
));
3768 x
= fold_convert_loc (clause_loc
, ptype
, x
);
3769 tree y
= create_tmp_var (ptype
, name
);
3770 gimplify_assign (y
, x
, ilist
);
3774 if (!integer_zerop (bias
))
3776 bias
= fold_convert_loc (clause_loc
, pointer_sized_int_node
,
3778 yb
= fold_convert_loc (clause_loc
, pointer_sized_int_node
,
3780 yb
= fold_build2_loc (clause_loc
, MINUS_EXPR
,
3781 pointer_sized_int_node
, yb
, bias
);
3782 x
= fold_convert_loc (clause_loc
, TREE_TYPE (x
), yb
);
3783 yb
= create_tmp_var (ptype
, name
);
3784 gimplify_assign (yb
, x
, ilist
);
3788 d
= TREE_OPERAND (d
, 0);
3789 if (TREE_CODE (d
) == POINTER_PLUS_EXPR
)
3790 d
= TREE_OPERAND (d
, 0);
3791 if (TREE_CODE (d
) == ADDR_EXPR
)
3793 if (orig_var
!= var
)
3795 gcc_assert (is_variable_sized (orig_var
));
3796 x
= fold_convert_loc (clause_loc
, TREE_TYPE (new_var
),
3798 gimplify_assign (new_var
, x
, ilist
);
3799 tree new_orig_var
= lookup_decl (orig_var
, ctx
);
3800 tree t
= build_fold_indirect_ref (new_var
);
3801 DECL_IGNORED_P (new_var
) = 0;
3802 TREE_THIS_NOTRAP (t
);
3803 SET_DECL_VALUE_EXPR (new_orig_var
, t
);
3804 DECL_HAS_VALUE_EXPR_P (new_orig_var
) = 1;
3808 x
= build2 (MEM_REF
, TREE_TYPE (new_var
), x
,
3809 build_int_cst (ptype
, 0));
3810 SET_DECL_VALUE_EXPR (new_var
, x
);
3811 DECL_HAS_VALUE_EXPR_P (new_var
) = 1;
3816 gcc_assert (orig_var
== var
);
3817 if (TREE_CODE (d
) == INDIRECT_REF
)
3819 x
= create_tmp_var (ptype
, name
);
3820 TREE_ADDRESSABLE (x
) = 1;
3821 gimplify_assign (x
, yb
, ilist
);
3822 x
= build_fold_addr_expr_loc (clause_loc
, x
);
3824 x
= fold_convert_loc (clause_loc
, TREE_TYPE (new_var
), x
);
3825 gimplify_assign (new_var
, x
, ilist
);
3827 tree y1
= create_tmp_var (ptype
, NULL
);
3828 gimplify_assign (y1
, y
, ilist
);
3829 tree i2
= NULL_TREE
, y2
= NULL_TREE
;
3830 tree body2
= NULL_TREE
, end2
= NULL_TREE
;
3831 tree y3
= NULL_TREE
, y4
= NULL_TREE
;
3832 if (OMP_CLAUSE_REDUCTION_PLACEHOLDER (c
) || is_simd
)
3834 y2
= create_tmp_var (ptype
, NULL
);
3835 gimplify_assign (y2
, y
, ilist
);
3836 tree ref
= build_outer_var_ref (var
, ctx
);
3837 /* For ref build_outer_var_ref already performs this. */
3838 if (TREE_CODE (d
) == INDIRECT_REF
)
3839 gcc_assert (omp_is_reference (var
));
3840 else if (TREE_CODE (d
) == ADDR_EXPR
)
3841 ref
= build_fold_addr_expr (ref
);
3842 else if (omp_is_reference (var
))
3843 ref
= build_fold_addr_expr (ref
);
3844 ref
= fold_convert_loc (clause_loc
, ptype
, ref
);
3845 if (OMP_CLAUSE_REDUCTION_PLACEHOLDER (c
)
3846 && OMP_CLAUSE_REDUCTION_OMP_ORIG_REF (c
))
3848 y3
= create_tmp_var (ptype
, NULL
);
3849 gimplify_assign (y3
, unshare_expr (ref
), ilist
);
3853 y4
= create_tmp_var (ptype
, NULL
);
3854 gimplify_assign (y4
, ref
, dlist
);
3857 tree i
= create_tmp_var (TREE_TYPE (v
), NULL
);
3858 gimplify_assign (i
, build_int_cst (TREE_TYPE (v
), 0), ilist
);
3859 tree body
= create_artificial_label (UNKNOWN_LOCATION
);
3860 tree end
= create_artificial_label (UNKNOWN_LOCATION
);
3861 gimple_seq_add_stmt (ilist
, gimple_build_label (body
));
3864 i2
= create_tmp_var (TREE_TYPE (v
), NULL
);
3865 gimplify_assign (i2
, build_int_cst (TREE_TYPE (v
), 0), dlist
);
3866 body2
= create_artificial_label (UNKNOWN_LOCATION
);
3867 end2
= create_artificial_label (UNKNOWN_LOCATION
);
3868 gimple_seq_add_stmt (dlist
, gimple_build_label (body2
));
3870 if (OMP_CLAUSE_REDUCTION_PLACEHOLDER (c
))
3872 tree placeholder
= OMP_CLAUSE_REDUCTION_PLACEHOLDER (c
);
3873 tree decl_placeholder
3874 = OMP_CLAUSE_REDUCTION_DECL_PLACEHOLDER (c
);
3875 SET_DECL_VALUE_EXPR (decl_placeholder
,
3876 build_simple_mem_ref (y1
));
3877 DECL_HAS_VALUE_EXPR_P (decl_placeholder
) = 1;
3878 SET_DECL_VALUE_EXPR (placeholder
,
3879 y3
? build_simple_mem_ref (y3
)
3881 DECL_HAS_VALUE_EXPR_P (placeholder
) = 1;
3882 x
= lang_hooks
.decls
.omp_clause_default_ctor
3883 (c
, build_simple_mem_ref (y1
),
3884 y3
? build_simple_mem_ref (y3
) : NULL_TREE
);
3886 gimplify_and_add (x
, ilist
);
3887 if (OMP_CLAUSE_REDUCTION_GIMPLE_INIT (c
))
3889 gimple_seq tseq
= OMP_CLAUSE_REDUCTION_GIMPLE_INIT (c
);
3890 lower_omp (&tseq
, ctx
);
3891 gimple_seq_add_seq (ilist
, tseq
);
3893 OMP_CLAUSE_REDUCTION_GIMPLE_INIT (c
) = NULL
;
3896 SET_DECL_VALUE_EXPR (decl_placeholder
,
3897 build_simple_mem_ref (y2
));
3898 SET_DECL_VALUE_EXPR (placeholder
,
3899 build_simple_mem_ref (y4
));
3900 gimple_seq tseq
= OMP_CLAUSE_REDUCTION_GIMPLE_MERGE (c
);
3901 lower_omp (&tseq
, ctx
);
3902 gimple_seq_add_seq (dlist
, tseq
);
3903 OMP_CLAUSE_REDUCTION_GIMPLE_MERGE (c
) = NULL
;
3905 DECL_HAS_VALUE_EXPR_P (placeholder
) = 0;
3906 DECL_HAS_VALUE_EXPR_P (decl_placeholder
) = 0;
3907 x
= lang_hooks
.decls
.omp_clause_dtor
3908 (c
, build_simple_mem_ref (y2
));
3911 gimple_seq tseq
= NULL
;
3913 gimplify_stmt (&dtor
, &tseq
);
3914 gimple_seq_add_seq (dlist
, tseq
);
3919 x
= omp_reduction_init (c
, TREE_TYPE (type
));
3920 enum tree_code code
= OMP_CLAUSE_REDUCTION_CODE (c
);
3922 /* reduction(-:var) sums up the partial results, so it
3923 acts identically to reduction(+:var). */
3924 if (code
== MINUS_EXPR
)
3927 gimplify_assign (build_simple_mem_ref (y1
), x
, ilist
);
3930 x
= build2 (code
, TREE_TYPE (type
),
3931 build_simple_mem_ref (y4
),
3932 build_simple_mem_ref (y2
));
3933 gimplify_assign (build_simple_mem_ref (y4
), x
, dlist
);
3937 = gimple_build_assign (y1
, POINTER_PLUS_EXPR
, y1
,
3938 TYPE_SIZE_UNIT (TREE_TYPE (type
)));
3939 gimple_seq_add_stmt (ilist
, g
);
3942 g
= gimple_build_assign (y3
, POINTER_PLUS_EXPR
, y3
,
3943 TYPE_SIZE_UNIT (TREE_TYPE (type
)));
3944 gimple_seq_add_stmt (ilist
, g
);
3946 g
= gimple_build_assign (i
, PLUS_EXPR
, i
,
3947 build_int_cst (TREE_TYPE (i
), 1));
3948 gimple_seq_add_stmt (ilist
, g
);
3949 g
= gimple_build_cond (LE_EXPR
, i
, v
, body
, end
);
3950 gimple_seq_add_stmt (ilist
, g
);
3951 gimple_seq_add_stmt (ilist
, gimple_build_label (end
));
3954 g
= gimple_build_assign (y2
, POINTER_PLUS_EXPR
, y2
,
3955 TYPE_SIZE_UNIT (TREE_TYPE (type
)));
3956 gimple_seq_add_stmt (dlist
, g
);
3959 g
= gimple_build_assign
3960 (y4
, POINTER_PLUS_EXPR
, y4
,
3961 TYPE_SIZE_UNIT (TREE_TYPE (type
)));
3962 gimple_seq_add_stmt (dlist
, g
);
3964 g
= gimple_build_assign (i2
, PLUS_EXPR
, i2
,
3965 build_int_cst (TREE_TYPE (i2
), 1));
3966 gimple_seq_add_stmt (dlist
, g
);
3967 g
= gimple_build_cond (LE_EXPR
, i2
, v
, body2
, end2
);
3968 gimple_seq_add_stmt (dlist
, g
);
3969 gimple_seq_add_stmt (dlist
, gimple_build_label (end2
));
3973 else if (is_variable_sized (var
))
3975 /* For variable sized types, we need to allocate the
3976 actual storage here. Call alloca and store the
3977 result in the pointer decl that we created elsewhere. */
3981 if (c_kind
!= OMP_CLAUSE_FIRSTPRIVATE
|| !is_task_ctx (ctx
))
3986 ptr
= DECL_VALUE_EXPR (new_var
);
3987 gcc_assert (TREE_CODE (ptr
) == INDIRECT_REF
);
3988 ptr
= TREE_OPERAND (ptr
, 0);
3989 gcc_assert (DECL_P (ptr
));
3990 x
= TYPE_SIZE_UNIT (TREE_TYPE (new_var
));
3992 /* void *tmp = __builtin_alloca */
3993 atmp
= builtin_decl_explicit (BUILT_IN_ALLOCA_WITH_ALIGN
);
3994 stmt
= gimple_build_call (atmp
, 2, x
,
3995 size_int (DECL_ALIGN (var
)));
3996 tmp
= create_tmp_var_raw (ptr_type_node
);
3997 gimple_add_tmp_var (tmp
);
3998 gimple_call_set_lhs (stmt
, tmp
);
4000 gimple_seq_add_stmt (ilist
, stmt
);
4002 x
= fold_convert_loc (clause_loc
, TREE_TYPE (ptr
), tmp
);
4003 gimplify_assign (ptr
, x
, ilist
);
4006 else if (omp_is_reference (var
))
4008 /* For references that are being privatized for Fortran,
4009 allocate new backing storage for the new pointer
4010 variable. This allows us to avoid changing all the
4011 code that expects a pointer to something that expects
4012 a direct variable. */
4016 x
= TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (new_var
)));
4017 if (c_kind
== OMP_CLAUSE_FIRSTPRIVATE
&& is_task_ctx (ctx
))
4019 x
= build_receiver_ref (var
, false, ctx
);
4020 x
= build_fold_addr_expr_loc (clause_loc
, x
);
4022 else if (TREE_CONSTANT (x
))
4024 /* For reduction in SIMD loop, defer adding the
4025 initialization of the reference, because if we decide
4026 to use SIMD array for it, the initilization could cause
4028 if (c_kind
== OMP_CLAUSE_REDUCTION
&& is_simd
)
4032 x
= create_tmp_var_raw (TREE_TYPE (TREE_TYPE (new_var
)),
4034 gimple_add_tmp_var (x
);
4035 TREE_ADDRESSABLE (x
) = 1;
4036 x
= build_fold_addr_expr_loc (clause_loc
, x
);
4042 = builtin_decl_explicit (BUILT_IN_ALLOCA_WITH_ALIGN
);
4043 tree rtype
= TREE_TYPE (TREE_TYPE (new_var
));
4044 tree al
= size_int (TYPE_ALIGN (rtype
));
4045 x
= build_call_expr_loc (clause_loc
, atmp
, 2, x
, al
);
4050 x
= fold_convert_loc (clause_loc
, TREE_TYPE (new_var
), x
);
4051 gimplify_assign (new_var
, x
, ilist
);
4054 new_var
= build_simple_mem_ref_loc (clause_loc
, new_var
);
4056 else if (c_kind
== OMP_CLAUSE_REDUCTION
4057 && OMP_CLAUSE_REDUCTION_PLACEHOLDER (c
))
4065 switch (OMP_CLAUSE_CODE (c
))
4067 case OMP_CLAUSE_SHARED
:
4068 /* Ignore shared directives in teams construct. */
4069 if (gimple_code (ctx
->stmt
) == GIMPLE_OMP_TEAMS
)
4071 /* Shared global vars are just accessed directly. */
4072 if (is_global_var (new_var
))
4074 /* For taskloop firstprivate/lastprivate, represented
4075 as firstprivate and shared clause on the task, new_var
4076 is the firstprivate var. */
4077 if (OMP_CLAUSE_SHARED_FIRSTPRIVATE (c
))
4079 /* Set up the DECL_VALUE_EXPR for shared variables now. This
4080 needs to be delayed until after fixup_child_record_type so
4081 that we get the correct type during the dereference. */
4082 by_ref
= use_pointer_for_field (var
, ctx
);
4083 x
= build_receiver_ref (var
, by_ref
, ctx
);
4084 SET_DECL_VALUE_EXPR (new_var
, x
);
4085 DECL_HAS_VALUE_EXPR_P (new_var
) = 1;
4087 /* ??? If VAR is not passed by reference, and the variable
4088 hasn't been initialized yet, then we'll get a warning for
4089 the store into the omp_data_s structure. Ideally, we'd be
4090 able to notice this and not store anything at all, but
4091 we're generating code too early. Suppress the warning. */
4093 TREE_NO_WARNING (var
) = 1;
4096 case OMP_CLAUSE_LASTPRIVATE
:
4097 if (OMP_CLAUSE_LASTPRIVATE_FIRSTPRIVATE (c
))
4101 case OMP_CLAUSE_PRIVATE
:
4102 if (OMP_CLAUSE_CODE (c
) != OMP_CLAUSE_PRIVATE
)
4103 x
= build_outer_var_ref (var
, ctx
);
4104 else if (OMP_CLAUSE_PRIVATE_OUTER_REF (c
))
4106 if (is_task_ctx (ctx
))
4107 x
= build_receiver_ref (var
, false, ctx
);
4109 x
= build_outer_var_ref (var
, ctx
, OMP_CLAUSE_PRIVATE
);
4115 nx
= lang_hooks
.decls
.omp_clause_default_ctor
4116 (c
, unshare_expr (new_var
), x
);
4119 tree y
= lang_hooks
.decls
.omp_clause_dtor (c
, new_var
);
4120 if ((TREE_ADDRESSABLE (new_var
) || nx
|| y
4121 || OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_LASTPRIVATE
)
4122 && lower_rec_simd_input_clauses (new_var
, ctx
, &sctx
,
4126 x
= lang_hooks
.decls
.omp_clause_default_ctor
4127 (c
, unshare_expr (ivar
), x
);
4129 gimplify_and_add (x
, &llist
[0]);
4132 y
= lang_hooks
.decls
.omp_clause_dtor (c
, ivar
);
4135 gimple_seq tseq
= NULL
;
4138 gimplify_stmt (&dtor
, &tseq
);
4139 gimple_seq_add_seq (&llist
[1], tseq
);
4146 gimplify_and_add (nx
, ilist
);
4150 x
= lang_hooks
.decls
.omp_clause_dtor (c
, new_var
);
4153 gimple_seq tseq
= NULL
;
4156 gimplify_stmt (&dtor
, &tseq
);
4157 gimple_seq_add_seq (dlist
, tseq
);
4161 case OMP_CLAUSE_LINEAR
:
4162 if (!OMP_CLAUSE_LINEAR_NO_COPYIN (c
))
4163 goto do_firstprivate
;
4164 if (OMP_CLAUSE_LINEAR_NO_COPYOUT (c
))
4167 x
= build_outer_var_ref (var
, ctx
);
4170 case OMP_CLAUSE_FIRSTPRIVATE
:
4171 if (is_task_ctx (ctx
))
4173 if (omp_is_reference (var
) || is_variable_sized (var
))
4175 else if (is_global_var (maybe_lookup_decl_in_outer_ctx (var
,
4177 || use_pointer_for_field (var
, NULL
))
4179 x
= build_receiver_ref (var
, false, ctx
);
4180 SET_DECL_VALUE_EXPR (new_var
, x
);
4181 DECL_HAS_VALUE_EXPR_P (new_var
) = 1;
4186 x
= build_outer_var_ref (var
, ctx
);
4189 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_LINEAR
4190 && gimple_omp_for_combined_into_p (ctx
->stmt
))
4192 tree t
= OMP_CLAUSE_LINEAR_STEP (c
);
4193 tree stept
= TREE_TYPE (t
);
4194 tree ct
= omp_find_clause (clauses
,
4195 OMP_CLAUSE__LOOPTEMP_
);
4197 tree l
= OMP_CLAUSE_DECL (ct
);
4198 tree n1
= fd
->loop
.n1
;
4199 tree step
= fd
->loop
.step
;
4200 tree itype
= TREE_TYPE (l
);
4201 if (POINTER_TYPE_P (itype
))
4202 itype
= signed_type_for (itype
);
4203 l
= fold_build2 (MINUS_EXPR
, itype
, l
, n1
);
4204 if (TYPE_UNSIGNED (itype
)
4205 && fd
->loop
.cond_code
== GT_EXPR
)
4206 l
= fold_build2 (TRUNC_DIV_EXPR
, itype
,
4207 fold_build1 (NEGATE_EXPR
, itype
, l
),
4208 fold_build1 (NEGATE_EXPR
,
4211 l
= fold_build2 (TRUNC_DIV_EXPR
, itype
, l
, step
);
4212 t
= fold_build2 (MULT_EXPR
, stept
,
4213 fold_convert (stept
, l
), t
);
4215 if (OMP_CLAUSE_LINEAR_ARRAY (c
))
4217 x
= lang_hooks
.decls
.omp_clause_linear_ctor
4219 gimplify_and_add (x
, ilist
);
4223 if (POINTER_TYPE_P (TREE_TYPE (x
)))
4224 x
= fold_build2 (POINTER_PLUS_EXPR
,
4225 TREE_TYPE (x
), x
, t
);
4227 x
= fold_build2 (PLUS_EXPR
, TREE_TYPE (x
), x
, t
);
4230 if ((OMP_CLAUSE_CODE (c
) != OMP_CLAUSE_LINEAR
4231 || TREE_ADDRESSABLE (new_var
))
4232 && lower_rec_simd_input_clauses (new_var
, ctx
, &sctx
,
4235 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_LINEAR
)
4237 tree iv
= create_tmp_var (TREE_TYPE (new_var
));
4238 x
= lang_hooks
.decls
.omp_clause_copy_ctor (c
, iv
, x
);
4239 gimplify_and_add (x
, ilist
);
4240 gimple_stmt_iterator gsi
4241 = gsi_start_1 (gimple_omp_body_ptr (ctx
->stmt
));
4243 = gimple_build_assign (unshare_expr (lvar
), iv
);
4244 gsi_insert_before_without_update (&gsi
, g
,
4246 tree t
= OMP_CLAUSE_LINEAR_STEP (c
);
4247 enum tree_code code
= PLUS_EXPR
;
4248 if (POINTER_TYPE_P (TREE_TYPE (new_var
)))
4249 code
= POINTER_PLUS_EXPR
;
4250 g
= gimple_build_assign (iv
, code
, iv
, t
);
4251 gsi_insert_before_without_update (&gsi
, g
,
4255 x
= lang_hooks
.decls
.omp_clause_copy_ctor
4256 (c
, unshare_expr (ivar
), x
);
4257 gimplify_and_add (x
, &llist
[0]);
4258 x
= lang_hooks
.decls
.omp_clause_dtor (c
, ivar
);
4261 gimple_seq tseq
= NULL
;
4264 gimplify_stmt (&dtor
, &tseq
);
4265 gimple_seq_add_seq (&llist
[1], tseq
);
4270 x
= lang_hooks
.decls
.omp_clause_copy_ctor
4271 (c
, unshare_expr (new_var
), x
);
4272 gimplify_and_add (x
, ilist
);
4275 case OMP_CLAUSE__LOOPTEMP_
:
4276 gcc_assert (is_taskreg_ctx (ctx
));
4277 x
= build_outer_var_ref (var
, ctx
);
4278 x
= build2 (MODIFY_EXPR
, TREE_TYPE (new_var
), new_var
, x
);
4279 gimplify_and_add (x
, ilist
);
4282 case OMP_CLAUSE_COPYIN
:
4283 by_ref
= use_pointer_for_field (var
, NULL
);
4284 x
= build_receiver_ref (var
, by_ref
, ctx
);
4285 x
= lang_hooks
.decls
.omp_clause_assign_op (c
, new_var
, x
);
4286 append_to_statement_list (x
, ©in_seq
);
4287 copyin_by_ref
|= by_ref
;
4290 case OMP_CLAUSE_REDUCTION
:
4291 /* OpenACC reductions are initialized using the
4292 GOACC_REDUCTION internal function. */
4293 if (is_gimple_omp_oacc (ctx
->stmt
))
4295 if (OMP_CLAUSE_REDUCTION_PLACEHOLDER (c
))
4297 tree placeholder
= OMP_CLAUSE_REDUCTION_PLACEHOLDER (c
);
4299 x
= build_outer_var_ref (var
, ctx
);
4301 if (omp_is_reference (var
)
4302 && !useless_type_conversion_p (TREE_TYPE (placeholder
),
4304 x
= build_fold_addr_expr_loc (clause_loc
, x
);
4305 SET_DECL_VALUE_EXPR (placeholder
, x
);
4306 DECL_HAS_VALUE_EXPR_P (placeholder
) = 1;
4307 tree new_vard
= new_var
;
4308 if (omp_is_reference (var
))
4310 gcc_assert (TREE_CODE (new_var
) == MEM_REF
);
4311 new_vard
= TREE_OPERAND (new_var
, 0);
4312 gcc_assert (DECL_P (new_vard
));
4315 && lower_rec_simd_input_clauses (new_var
, ctx
, &sctx
,
4318 if (new_vard
== new_var
)
4320 gcc_assert (DECL_VALUE_EXPR (new_var
) == lvar
);
4321 SET_DECL_VALUE_EXPR (new_var
, ivar
);
4325 SET_DECL_VALUE_EXPR (new_vard
,
4326 build_fold_addr_expr (ivar
));
4327 DECL_HAS_VALUE_EXPR_P (new_vard
) = 1;
4329 x
= lang_hooks
.decls
.omp_clause_default_ctor
4330 (c
, unshare_expr (ivar
),
4331 build_outer_var_ref (var
, ctx
));
4333 gimplify_and_add (x
, &llist
[0]);
4334 if (OMP_CLAUSE_REDUCTION_GIMPLE_INIT (c
))
4336 tseq
= OMP_CLAUSE_REDUCTION_GIMPLE_INIT (c
);
4337 lower_omp (&tseq
, ctx
);
4338 gimple_seq_add_seq (&llist
[0], tseq
);
4340 OMP_CLAUSE_REDUCTION_GIMPLE_INIT (c
) = NULL
;
4341 tseq
= OMP_CLAUSE_REDUCTION_GIMPLE_MERGE (c
);
4342 lower_omp (&tseq
, ctx
);
4343 gimple_seq_add_seq (&llist
[1], tseq
);
4344 OMP_CLAUSE_REDUCTION_GIMPLE_MERGE (c
) = NULL
;
4345 DECL_HAS_VALUE_EXPR_P (placeholder
) = 0;
4346 if (new_vard
== new_var
)
4347 SET_DECL_VALUE_EXPR (new_var
, lvar
);
4349 SET_DECL_VALUE_EXPR (new_vard
,
4350 build_fold_addr_expr (lvar
));
4351 x
= lang_hooks
.decls
.omp_clause_dtor (c
, ivar
);
4356 gimplify_stmt (&dtor
, &tseq
);
4357 gimple_seq_add_seq (&llist
[1], tseq
);
4361 /* If this is a reference to constant size reduction var
4362 with placeholder, we haven't emitted the initializer
4363 for it because it is undesirable if SIMD arrays are used.
4364 But if they aren't used, we need to emit the deferred
4365 initialization now. */
4366 else if (omp_is_reference (var
) && is_simd
)
4367 handle_simd_reference (clause_loc
, new_vard
, ilist
);
4368 x
= lang_hooks
.decls
.omp_clause_default_ctor
4369 (c
, unshare_expr (new_var
),
4370 build_outer_var_ref (var
, ctx
));
4372 gimplify_and_add (x
, ilist
);
4373 if (OMP_CLAUSE_REDUCTION_GIMPLE_INIT (c
))
4375 tseq
= OMP_CLAUSE_REDUCTION_GIMPLE_INIT (c
);
4376 lower_omp (&tseq
, ctx
);
4377 gimple_seq_add_seq (ilist
, tseq
);
4379 OMP_CLAUSE_REDUCTION_GIMPLE_INIT (c
) = NULL
;
4382 tseq
= OMP_CLAUSE_REDUCTION_GIMPLE_MERGE (c
);
4383 lower_omp (&tseq
, ctx
);
4384 gimple_seq_add_seq (dlist
, tseq
);
4385 OMP_CLAUSE_REDUCTION_GIMPLE_MERGE (c
) = NULL
;
4387 DECL_HAS_VALUE_EXPR_P (placeholder
) = 0;
4392 x
= omp_reduction_init (c
, TREE_TYPE (new_var
));
4393 gcc_assert (TREE_CODE (TREE_TYPE (new_var
)) != ARRAY_TYPE
);
4394 enum tree_code code
= OMP_CLAUSE_REDUCTION_CODE (c
);
4396 /* reduction(-:var) sums up the partial results, so it
4397 acts identically to reduction(+:var). */
4398 if (code
== MINUS_EXPR
)
4401 tree new_vard
= new_var
;
4402 if (is_simd
&& omp_is_reference (var
))
4404 gcc_assert (TREE_CODE (new_var
) == MEM_REF
);
4405 new_vard
= TREE_OPERAND (new_var
, 0);
4406 gcc_assert (DECL_P (new_vard
));
4409 && lower_rec_simd_input_clauses (new_var
, ctx
, &sctx
,
4412 tree ref
= build_outer_var_ref (var
, ctx
);
4414 gimplify_assign (unshare_expr (ivar
), x
, &llist
[0]);
4419 simt_lane
= create_tmp_var (unsigned_type_node
);
4420 x
= build_call_expr_internal_loc
4421 (UNKNOWN_LOCATION
, IFN_GOMP_SIMT_XCHG_BFLY
,
4422 TREE_TYPE (ivar
), 2, ivar
, simt_lane
);
4423 x
= build2 (code
, TREE_TYPE (ivar
), ivar
, x
);
4424 gimplify_assign (ivar
, x
, &llist
[2]);
4426 x
= build2 (code
, TREE_TYPE (ref
), ref
, ivar
);
4427 ref
= build_outer_var_ref (var
, ctx
);
4428 gimplify_assign (ref
, x
, &llist
[1]);
4430 if (new_vard
!= new_var
)
4432 SET_DECL_VALUE_EXPR (new_vard
,
4433 build_fold_addr_expr (lvar
));
4434 DECL_HAS_VALUE_EXPR_P (new_vard
) = 1;
4439 if (omp_is_reference (var
) && is_simd
)
4440 handle_simd_reference (clause_loc
, new_vard
, ilist
);
4441 gimplify_assign (new_var
, x
, ilist
);
4444 tree ref
= build_outer_var_ref (var
, ctx
);
4446 x
= build2 (code
, TREE_TYPE (ref
), ref
, new_var
);
4447 ref
= build_outer_var_ref (var
, ctx
);
4448 gimplify_assign (ref
, x
, dlist
);
4460 if (known_eq (sctx
.max_vf
, 1U))
4461 sctx
.is_simt
= false;
4463 if (sctx
.lane
|| sctx
.is_simt
)
4465 uid
= create_tmp_var (ptr_type_node
, "simduid");
4466 /* Don't want uninit warnings on simduid, it is always uninitialized,
4467 but we use it not for the value, but for the DECL_UID only. */
4468 TREE_NO_WARNING (uid
) = 1;
4469 c
= build_omp_clause (UNKNOWN_LOCATION
, OMP_CLAUSE__SIMDUID_
);
4470 OMP_CLAUSE__SIMDUID__DECL (c
) = uid
;
4471 OMP_CLAUSE_CHAIN (c
) = gimple_omp_for_clauses (ctx
->stmt
);
4472 gimple_omp_for_set_clauses (ctx
->stmt
, c
);
4474 /* Emit calls denoting privatized variables and initializing a pointer to
4475 structure that holds private variables as fields after ompdevlow pass. */
4478 sctx
.simt_eargs
[0] = uid
;
4480 = gimple_build_call_internal_vec (IFN_GOMP_SIMT_ENTER
, sctx
.simt_eargs
);
4481 gimple_call_set_lhs (g
, uid
);
4482 gimple_seq_add_stmt (ilist
, g
);
4483 sctx
.simt_eargs
.release ();
4485 simtrec
= create_tmp_var (ptr_type_node
, ".omp_simt");
4486 g
= gimple_build_call_internal (IFN_GOMP_SIMT_ENTER_ALLOC
, 1, uid
);
4487 gimple_call_set_lhs (g
, simtrec
);
4488 gimple_seq_add_stmt (ilist
, g
);
4493 = gimple_build_call_internal (IFN_GOMP_SIMD_LANE
, 1, uid
);
4494 gimple_call_set_lhs (g
, sctx
.lane
);
4495 gimple_stmt_iterator gsi
= gsi_start_1 (gimple_omp_body_ptr (ctx
->stmt
));
4496 gsi_insert_before_without_update (&gsi
, g
, GSI_SAME_STMT
);
4497 g
= gimple_build_assign (sctx
.lane
, INTEGER_CST
,
4498 build_int_cst (unsigned_type_node
, 0));
4499 gimple_seq_add_stmt (ilist
, g
);
4500 /* Emit reductions across SIMT lanes in log_2(simt_vf) steps. */
4503 tree simt_vf
= create_tmp_var (unsigned_type_node
);
4504 g
= gimple_build_call_internal (IFN_GOMP_SIMT_VF
, 0);
4505 gimple_call_set_lhs (g
, simt_vf
);
4506 gimple_seq_add_stmt (dlist
, g
);
4508 tree t
= build_int_cst (unsigned_type_node
, 1);
4509 g
= gimple_build_assign (simt_lane
, INTEGER_CST
, t
);
4510 gimple_seq_add_stmt (dlist
, g
);
4512 t
= build_int_cst (unsigned_type_node
, 0);
4513 g
= gimple_build_assign (sctx
.idx
, INTEGER_CST
, t
);
4514 gimple_seq_add_stmt (dlist
, g
);
4516 tree body
= create_artificial_label (UNKNOWN_LOCATION
);
4517 tree header
= create_artificial_label (UNKNOWN_LOCATION
);
4518 tree end
= create_artificial_label (UNKNOWN_LOCATION
);
4519 gimple_seq_add_stmt (dlist
, gimple_build_goto (header
));
4520 gimple_seq_add_stmt (dlist
, gimple_build_label (body
));
4522 gimple_seq_add_seq (dlist
, llist
[2]);
4524 g
= gimple_build_assign (simt_lane
, LSHIFT_EXPR
, simt_lane
, integer_one_node
);
4525 gimple_seq_add_stmt (dlist
, g
);
4527 gimple_seq_add_stmt (dlist
, gimple_build_label (header
));
4528 g
= gimple_build_cond (LT_EXPR
, simt_lane
, simt_vf
, body
, end
);
4529 gimple_seq_add_stmt (dlist
, g
);
4531 gimple_seq_add_stmt (dlist
, gimple_build_label (end
));
4533 for (int i
= 0; i
< 2; i
++)
4536 tree vf
= create_tmp_var (unsigned_type_node
);
4537 g
= gimple_build_call_internal (IFN_GOMP_SIMD_VF
, 1, uid
);
4538 gimple_call_set_lhs (g
, vf
);
4539 gimple_seq
*seq
= i
== 0 ? ilist
: dlist
;
4540 gimple_seq_add_stmt (seq
, g
);
4541 tree t
= build_int_cst (unsigned_type_node
, 0);
4542 g
= gimple_build_assign (sctx
.idx
, INTEGER_CST
, t
);
4543 gimple_seq_add_stmt (seq
, g
);
4544 tree body
= create_artificial_label (UNKNOWN_LOCATION
);
4545 tree header
= create_artificial_label (UNKNOWN_LOCATION
);
4546 tree end
= create_artificial_label (UNKNOWN_LOCATION
);
4547 gimple_seq_add_stmt (seq
, gimple_build_goto (header
));
4548 gimple_seq_add_stmt (seq
, gimple_build_label (body
));
4549 gimple_seq_add_seq (seq
, llist
[i
]);
4550 t
= build_int_cst (unsigned_type_node
, 1);
4551 g
= gimple_build_assign (sctx
.idx
, PLUS_EXPR
, sctx
.idx
, t
);
4552 gimple_seq_add_stmt (seq
, g
);
4553 gimple_seq_add_stmt (seq
, gimple_build_label (header
));
4554 g
= gimple_build_cond (LT_EXPR
, sctx
.idx
, vf
, body
, end
);
4555 gimple_seq_add_stmt (seq
, g
);
4556 gimple_seq_add_stmt (seq
, gimple_build_label (end
));
4561 gimple_seq_add_seq (dlist
, sctx
.simt_dlist
);
4563 = gimple_build_call_internal (IFN_GOMP_SIMT_EXIT
, 1, simtrec
);
4564 gimple_seq_add_stmt (dlist
, g
);
4567 /* The copyin sequence is not to be executed by the main thread, since
4568 that would result in self-copies. Perhaps not visible to scalars,
4569 but it certainly is to C++ operator=. */
4572 x
= build_call_expr (builtin_decl_explicit (BUILT_IN_OMP_GET_THREAD_NUM
),
4574 x
= build2 (NE_EXPR
, boolean_type_node
, x
,
4575 build_int_cst (TREE_TYPE (x
), 0));
4576 x
= build3 (COND_EXPR
, void_type_node
, x
, copyin_seq
, NULL
);
4577 gimplify_and_add (x
, ilist
);
4580 /* If any copyin variable is passed by reference, we must ensure the
4581 master thread doesn't modify it before it is copied over in all
4582 threads. Similarly for variables in both firstprivate and
4583 lastprivate clauses we need to ensure the lastprivate copying
4584 happens after firstprivate copying in all threads. And similarly
4585 for UDRs if initializer expression refers to omp_orig. */
4586 if (copyin_by_ref
|| lastprivate_firstprivate
|| reduction_omp_orig_ref
)
4588 /* Don't add any barrier for #pragma omp simd or
4589 #pragma omp distribute. */
4590 if (gimple_code (ctx
->stmt
) != GIMPLE_OMP_FOR
4591 || gimple_omp_for_kind (ctx
->stmt
) == GF_OMP_FOR_KIND_FOR
)
4592 gimple_seq_add_stmt (ilist
, omp_build_barrier (NULL_TREE
));
4595 /* If max_vf is non-zero, then we can use only a vectorization factor
4596 up to the max_vf we chose. So stick it into the safelen clause. */
4597 if (maybe_ne (sctx
.max_vf
, 0U))
4599 tree c
= omp_find_clause (gimple_omp_for_clauses (ctx
->stmt
),
4600 OMP_CLAUSE_SAFELEN
);
4601 poly_uint64 safe_len
;
4603 || (poly_int_tree_p (OMP_CLAUSE_SAFELEN_EXPR (c
), &safe_len
)
4604 && maybe_gt (safe_len
, sctx
.max_vf
)))
4606 c
= build_omp_clause (UNKNOWN_LOCATION
, OMP_CLAUSE_SAFELEN
);
4607 OMP_CLAUSE_SAFELEN_EXPR (c
) = build_int_cst (integer_type_node
,
4609 OMP_CLAUSE_CHAIN (c
) = gimple_omp_for_clauses (ctx
->stmt
);
4610 gimple_omp_for_set_clauses (ctx
->stmt
, c
);
4616 /* Generate code to implement the LASTPRIVATE clauses. This is used for
4617 both parallel and workshare constructs. PREDICATE may be NULL if it's
4621 lower_lastprivate_clauses (tree clauses
, tree predicate
, gimple_seq
*stmt_list
,
4624 tree x
, c
, label
= NULL
, orig_clauses
= clauses
;
4625 bool par_clauses
= false;
4626 tree simduid
= NULL
, lastlane
= NULL
, simtcond
= NULL
, simtlast
= NULL
;
4628 /* Early exit if there are no lastprivate or linear clauses. */
4629 for (; clauses
; clauses
= OMP_CLAUSE_CHAIN (clauses
))
4630 if (OMP_CLAUSE_CODE (clauses
) == OMP_CLAUSE_LASTPRIVATE
4631 || (OMP_CLAUSE_CODE (clauses
) == OMP_CLAUSE_LINEAR
4632 && !OMP_CLAUSE_LINEAR_NO_COPYOUT (clauses
)))
4634 if (clauses
== NULL
)
4636 /* If this was a workshare clause, see if it had been combined
4637 with its parallel. In that case, look for the clauses on the
4638 parallel statement itself. */
4639 if (is_parallel_ctx (ctx
))
4643 if (ctx
== NULL
|| !is_parallel_ctx (ctx
))
4646 clauses
= omp_find_clause (gimple_omp_parallel_clauses (ctx
->stmt
),
4647 OMP_CLAUSE_LASTPRIVATE
);
4648 if (clauses
== NULL
)
4653 bool maybe_simt
= false;
4654 if (gimple_code (ctx
->stmt
) == GIMPLE_OMP_FOR
4655 && gimple_omp_for_kind (ctx
->stmt
) & GF_OMP_FOR_SIMD
)
4657 maybe_simt
= omp_find_clause (orig_clauses
, OMP_CLAUSE__SIMT_
);
4658 simduid
= omp_find_clause (orig_clauses
, OMP_CLAUSE__SIMDUID_
);
4660 simduid
= OMP_CLAUSE__SIMDUID__DECL (simduid
);
4666 tree label_true
, arm1
, arm2
;
4667 enum tree_code pred_code
= TREE_CODE (predicate
);
4669 label
= create_artificial_label (UNKNOWN_LOCATION
);
4670 label_true
= create_artificial_label (UNKNOWN_LOCATION
);
4671 if (TREE_CODE_CLASS (pred_code
) == tcc_comparison
)
4673 arm1
= TREE_OPERAND (predicate
, 0);
4674 arm2
= TREE_OPERAND (predicate
, 1);
4675 gimplify_expr (&arm1
, stmt_list
, NULL
, is_gimple_val
, fb_rvalue
);
4676 gimplify_expr (&arm2
, stmt_list
, NULL
, is_gimple_val
, fb_rvalue
);
4681 gimplify_expr (&arm1
, stmt_list
, NULL
, is_gimple_val
, fb_rvalue
);
4682 arm2
= boolean_false_node
;
4683 pred_code
= NE_EXPR
;
4687 c
= build2 (pred_code
, boolean_type_node
, arm1
, arm2
);
4688 c
= fold_convert (integer_type_node
, c
);
4689 simtcond
= create_tmp_var (integer_type_node
);
4690 gimplify_assign (simtcond
, c
, stmt_list
);
4691 gcall
*g
= gimple_build_call_internal (IFN_GOMP_SIMT_VOTE_ANY
,
4693 c
= create_tmp_var (integer_type_node
);
4694 gimple_call_set_lhs (g
, c
);
4695 gimple_seq_add_stmt (stmt_list
, g
);
4696 stmt
= gimple_build_cond (NE_EXPR
, c
, integer_zero_node
,
4700 stmt
= gimple_build_cond (pred_code
, arm1
, arm2
, label_true
, label
);
4701 gimple_seq_add_stmt (stmt_list
, stmt
);
4702 gimple_seq_add_stmt (stmt_list
, gimple_build_label (label_true
));
4705 for (c
= clauses
; c
;)
4708 location_t clause_loc
= OMP_CLAUSE_LOCATION (c
);
4710 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_LASTPRIVATE
4711 || (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_LINEAR
4712 && !OMP_CLAUSE_LINEAR_NO_COPYOUT (c
)))
4714 var
= OMP_CLAUSE_DECL (c
);
4715 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_LASTPRIVATE
4716 && OMP_CLAUSE_LASTPRIVATE_FIRSTPRIVATE (c
)
4717 && is_taskloop_ctx (ctx
))
4719 gcc_checking_assert (ctx
->outer
&& is_task_ctx (ctx
->outer
));
4720 new_var
= lookup_decl (var
, ctx
->outer
);
4724 new_var
= lookup_decl (var
, ctx
);
4725 /* Avoid uninitialized warnings for lastprivate and
4726 for linear iterators. */
4728 && (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_LASTPRIVATE
4729 || OMP_CLAUSE_LINEAR_NO_COPYIN (c
)))
4730 TREE_NO_WARNING (new_var
) = 1;
4733 if (!maybe_simt
&& simduid
&& DECL_HAS_VALUE_EXPR_P (new_var
))
4735 tree val
= DECL_VALUE_EXPR (new_var
);
4736 if (TREE_CODE (val
) == ARRAY_REF
4737 && VAR_P (TREE_OPERAND (val
, 0))
4738 && lookup_attribute ("omp simd array",
4739 DECL_ATTRIBUTES (TREE_OPERAND (val
,
4742 if (lastlane
== NULL
)
4744 lastlane
= create_tmp_var (unsigned_type_node
);
4746 = gimple_build_call_internal (IFN_GOMP_SIMD_LAST_LANE
,
4748 TREE_OPERAND (val
, 1));
4749 gimple_call_set_lhs (g
, lastlane
);
4750 gimple_seq_add_stmt (stmt_list
, g
);
4752 new_var
= build4 (ARRAY_REF
, TREE_TYPE (val
),
4753 TREE_OPERAND (val
, 0), lastlane
,
4754 NULL_TREE
, NULL_TREE
);
4757 else if (maybe_simt
)
4759 tree val
= (DECL_HAS_VALUE_EXPR_P (new_var
)
4760 ? DECL_VALUE_EXPR (new_var
)
4762 if (simtlast
== NULL
)
4764 simtlast
= create_tmp_var (unsigned_type_node
);
4765 gcall
*g
= gimple_build_call_internal
4766 (IFN_GOMP_SIMT_LAST_LANE
, 1, simtcond
);
4767 gimple_call_set_lhs (g
, simtlast
);
4768 gimple_seq_add_stmt (stmt_list
, g
);
4770 x
= build_call_expr_internal_loc
4771 (UNKNOWN_LOCATION
, IFN_GOMP_SIMT_XCHG_IDX
,
4772 TREE_TYPE (val
), 2, val
, simtlast
);
4773 new_var
= unshare_expr (new_var
);
4774 gimplify_assign (new_var
, x
, stmt_list
);
4775 new_var
= unshare_expr (new_var
);
4778 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_LASTPRIVATE
4779 && OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (c
))
4781 lower_omp (&OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (c
), ctx
);
4782 gimple_seq_add_seq (stmt_list
,
4783 OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (c
));
4784 OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (c
) = NULL
;
4786 else if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_LINEAR
4787 && OMP_CLAUSE_LINEAR_GIMPLE_SEQ (c
))
4789 lower_omp (&OMP_CLAUSE_LINEAR_GIMPLE_SEQ (c
), ctx
);
4790 gimple_seq_add_seq (stmt_list
,
4791 OMP_CLAUSE_LINEAR_GIMPLE_SEQ (c
));
4792 OMP_CLAUSE_LINEAR_GIMPLE_SEQ (c
) = NULL
;
4796 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_LASTPRIVATE
4797 && OMP_CLAUSE_LASTPRIVATE_TASKLOOP_IV (c
))
4799 gcc_checking_assert (is_taskloop_ctx (ctx
));
4800 tree ovar
= maybe_lookup_decl_in_outer_ctx (var
,
4802 if (is_global_var (ovar
))
4806 x
= build_outer_var_ref (var
, ctx
, OMP_CLAUSE_LASTPRIVATE
);
4807 if (omp_is_reference (var
))
4808 new_var
= build_simple_mem_ref_loc (clause_loc
, new_var
);
4809 x
= lang_hooks
.decls
.omp_clause_assign_op (c
, x
, new_var
);
4810 gimplify_and_add (x
, stmt_list
);
4812 c
= OMP_CLAUSE_CHAIN (c
);
4813 if (c
== NULL
&& !par_clauses
)
4815 /* If this was a workshare clause, see if it had been combined
4816 with its parallel. In that case, continue looking for the
4817 clauses also on the parallel statement itself. */
4818 if (is_parallel_ctx (ctx
))
4822 if (ctx
== NULL
|| !is_parallel_ctx (ctx
))
4825 c
= omp_find_clause (gimple_omp_parallel_clauses (ctx
->stmt
),
4826 OMP_CLAUSE_LASTPRIVATE
);
4832 gimple_seq_add_stmt (stmt_list
, gimple_build_label (label
));
4835 /* Lower the OpenACC reductions of CLAUSES for compute axis LEVEL
4836 (which might be a placeholder). INNER is true if this is an inner
4837 axis of a multi-axis loop. FORK and JOIN are (optional) fork and
4838 join markers. Generate the before-loop forking sequence in
4839 FORK_SEQ and the after-loop joining sequence to JOIN_SEQ. The
4840 general form of these sequences is
4842 GOACC_REDUCTION_SETUP
4844 GOACC_REDUCTION_INIT
4846 GOACC_REDUCTION_FINI
4848 GOACC_REDUCTION_TEARDOWN. */
4851 lower_oacc_reductions (location_t loc
, tree clauses
, tree level
, bool inner
,
4852 gcall
*fork
, gcall
*join
, gimple_seq
*fork_seq
,
4853 gimple_seq
*join_seq
, omp_context
*ctx
)
4855 gimple_seq before_fork
= NULL
;
4856 gimple_seq after_fork
= NULL
;
4857 gimple_seq before_join
= NULL
;
4858 gimple_seq after_join
= NULL
;
4859 tree init_code
= NULL_TREE
, fini_code
= NULL_TREE
,
4860 setup_code
= NULL_TREE
, teardown_code
= NULL_TREE
;
4861 unsigned offset
= 0;
4863 for (tree c
= clauses
; c
; c
= OMP_CLAUSE_CHAIN (c
))
4864 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_REDUCTION
)
4866 tree orig
= OMP_CLAUSE_DECL (c
);
4867 tree var
= maybe_lookup_decl (orig
, ctx
);
4868 tree ref_to_res
= NULL_TREE
;
4869 tree incoming
, outgoing
, v1
, v2
, v3
;
4870 bool is_private
= false;
4872 enum tree_code rcode
= OMP_CLAUSE_REDUCTION_CODE (c
);
4873 if (rcode
== MINUS_EXPR
)
4875 else if (rcode
== TRUTH_ANDIF_EXPR
)
4876 rcode
= BIT_AND_EXPR
;
4877 else if (rcode
== TRUTH_ORIF_EXPR
)
4878 rcode
= BIT_IOR_EXPR
;
4879 tree op
= build_int_cst (unsigned_type_node
, rcode
);
4884 incoming
= outgoing
= var
;
4888 /* See if an outer construct also reduces this variable. */
4889 omp_context
*outer
= ctx
;
4891 while (omp_context
*probe
= outer
->outer
)
4893 enum gimple_code type
= gimple_code (probe
->stmt
);
4898 case GIMPLE_OMP_FOR
:
4899 cls
= gimple_omp_for_clauses (probe
->stmt
);
4902 case GIMPLE_OMP_TARGET
:
4903 if (gimple_omp_target_kind (probe
->stmt
)
4904 != GF_OMP_TARGET_KIND_OACC_PARALLEL
)
4907 cls
= gimple_omp_target_clauses (probe
->stmt
);
4915 for (; cls
; cls
= OMP_CLAUSE_CHAIN (cls
))
4916 if (OMP_CLAUSE_CODE (cls
) == OMP_CLAUSE_REDUCTION
4917 && orig
== OMP_CLAUSE_DECL (cls
))
4919 incoming
= outgoing
= lookup_decl (orig
, probe
);
4920 goto has_outer_reduction
;
4922 else if ((OMP_CLAUSE_CODE (cls
) == OMP_CLAUSE_FIRSTPRIVATE
4923 || OMP_CLAUSE_CODE (cls
) == OMP_CLAUSE_PRIVATE
)
4924 && orig
== OMP_CLAUSE_DECL (cls
))
4932 /* This is the outermost construct with this reduction,
4933 see if there's a mapping for it. */
4934 if (gimple_code (outer
->stmt
) == GIMPLE_OMP_TARGET
4935 && maybe_lookup_field (orig
, outer
) && !is_private
)
4937 ref_to_res
= build_receiver_ref (orig
, false, outer
);
4938 if (omp_is_reference (orig
))
4939 ref_to_res
= build_simple_mem_ref (ref_to_res
);
4941 tree type
= TREE_TYPE (var
);
4942 if (POINTER_TYPE_P (type
))
4943 type
= TREE_TYPE (type
);
4946 incoming
= omp_reduction_init_op (loc
, rcode
, type
);
4950 /* Try to look at enclosing contexts for reduction var,
4951 use original if no mapping found. */
4953 omp_context
*c
= ctx
->outer
;
4956 t
= maybe_lookup_decl (orig
, c
);
4959 incoming
= outgoing
= (t
? t
: orig
);
4962 has_outer_reduction
:;
4966 ref_to_res
= integer_zero_node
;
4968 if (omp_is_reference (orig
))
4970 tree type
= TREE_TYPE (var
);
4971 const char *id
= IDENTIFIER_POINTER (DECL_NAME (var
));
4975 tree x
= create_tmp_var (TREE_TYPE (type
), id
);
4976 gimplify_assign (var
, build_fold_addr_expr (x
), fork_seq
);
4979 v1
= create_tmp_var (type
, id
);
4980 v2
= create_tmp_var (type
, id
);
4981 v3
= create_tmp_var (type
, id
);
4983 gimplify_assign (v1
, var
, fork_seq
);
4984 gimplify_assign (v2
, var
, fork_seq
);
4985 gimplify_assign (v3
, var
, fork_seq
);
4987 var
= build_simple_mem_ref (var
);
4988 v1
= build_simple_mem_ref (v1
);
4989 v2
= build_simple_mem_ref (v2
);
4990 v3
= build_simple_mem_ref (v3
);
4991 outgoing
= build_simple_mem_ref (outgoing
);
4993 if (!TREE_CONSTANT (incoming
))
4994 incoming
= build_simple_mem_ref (incoming
);
4999 /* Determine position in reduction buffer, which may be used
5000 by target. The parser has ensured that this is not a
5001 variable-sized type. */
5002 fixed_size_mode mode
5003 = as_a
<fixed_size_mode
> (TYPE_MODE (TREE_TYPE (var
)));
5004 unsigned align
= GET_MODE_ALIGNMENT (mode
) / BITS_PER_UNIT
;
5005 offset
= (offset
+ align
- 1) & ~(align
- 1);
5006 tree off
= build_int_cst (sizetype
, offset
);
5007 offset
+= GET_MODE_SIZE (mode
);
5011 init_code
= build_int_cst (integer_type_node
,
5012 IFN_GOACC_REDUCTION_INIT
);
5013 fini_code
= build_int_cst (integer_type_node
,
5014 IFN_GOACC_REDUCTION_FINI
);
5015 setup_code
= build_int_cst (integer_type_node
,
5016 IFN_GOACC_REDUCTION_SETUP
);
5017 teardown_code
= build_int_cst (integer_type_node
,
5018 IFN_GOACC_REDUCTION_TEARDOWN
);
5022 = build_call_expr_internal_loc (loc
, IFN_GOACC_REDUCTION
,
5023 TREE_TYPE (var
), 6, setup_code
,
5024 unshare_expr (ref_to_res
),
5025 incoming
, level
, op
, off
);
5027 = build_call_expr_internal_loc (loc
, IFN_GOACC_REDUCTION
,
5028 TREE_TYPE (var
), 6, init_code
,
5029 unshare_expr (ref_to_res
),
5030 v1
, level
, op
, off
);
5032 = build_call_expr_internal_loc (loc
, IFN_GOACC_REDUCTION
,
5033 TREE_TYPE (var
), 6, fini_code
,
5034 unshare_expr (ref_to_res
),
5035 v2
, level
, op
, off
);
5037 = build_call_expr_internal_loc (loc
, IFN_GOACC_REDUCTION
,
5038 TREE_TYPE (var
), 6, teardown_code
,
5039 ref_to_res
, v3
, level
, op
, off
);
5041 gimplify_assign (v1
, setup_call
, &before_fork
);
5042 gimplify_assign (v2
, init_call
, &after_fork
);
5043 gimplify_assign (v3
, fini_call
, &before_join
);
5044 gimplify_assign (outgoing
, teardown_call
, &after_join
);
5047 /* Now stitch things together. */
5048 gimple_seq_add_seq (fork_seq
, before_fork
);
5050 gimple_seq_add_stmt (fork_seq
, fork
);
5051 gimple_seq_add_seq (fork_seq
, after_fork
);
5053 gimple_seq_add_seq (join_seq
, before_join
);
5055 gimple_seq_add_stmt (join_seq
, join
);
5056 gimple_seq_add_seq (join_seq
, after_join
);
5059 /* Generate code to implement the REDUCTION clauses. */
5062 lower_reduction_clauses (tree clauses
, gimple_seq
*stmt_seqp
, omp_context
*ctx
)
5064 gimple_seq sub_seq
= NULL
;
5069 /* OpenACC loop reductions are handled elsewhere. */
5070 if (is_gimple_omp_oacc (ctx
->stmt
))
5073 /* SIMD reductions are handled in lower_rec_input_clauses. */
5074 if (gimple_code (ctx
->stmt
) == GIMPLE_OMP_FOR
5075 && gimple_omp_for_kind (ctx
->stmt
) & GF_OMP_FOR_SIMD
)
5078 /* First see if there is exactly one reduction clause. Use OMP_ATOMIC
5079 update in that case, otherwise use a lock. */
5080 for (c
= clauses
; c
&& count
< 2; c
= OMP_CLAUSE_CHAIN (c
))
5081 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_REDUCTION
)
5083 if (OMP_CLAUSE_REDUCTION_PLACEHOLDER (c
)
5084 || TREE_CODE (OMP_CLAUSE_DECL (c
)) == MEM_REF
)
5086 /* Never use OMP_ATOMIC for array reductions or UDRs. */
5096 for (c
= clauses
; c
; c
= OMP_CLAUSE_CHAIN (c
))
5098 tree var
, ref
, new_var
, orig_var
;
5099 enum tree_code code
;
5100 location_t clause_loc
= OMP_CLAUSE_LOCATION (c
);
5102 if (OMP_CLAUSE_CODE (c
) != OMP_CLAUSE_REDUCTION
)
5105 enum omp_clause_code ccode
= OMP_CLAUSE_REDUCTION
;
5106 orig_var
= var
= OMP_CLAUSE_DECL (c
);
5107 if (TREE_CODE (var
) == MEM_REF
)
5109 var
= TREE_OPERAND (var
, 0);
5110 if (TREE_CODE (var
) == POINTER_PLUS_EXPR
)
5111 var
= TREE_OPERAND (var
, 0);
5112 if (TREE_CODE (var
) == ADDR_EXPR
)
5113 var
= TREE_OPERAND (var
, 0);
5116 /* If this is a pointer or referenced based array
5117 section, the var could be private in the outer
5118 context e.g. on orphaned loop construct. Pretend this
5119 is private variable's outer reference. */
5120 ccode
= OMP_CLAUSE_PRIVATE
;
5121 if (TREE_CODE (var
) == INDIRECT_REF
)
5122 var
= TREE_OPERAND (var
, 0);
5125 if (is_variable_sized (var
))
5127 gcc_assert (DECL_HAS_VALUE_EXPR_P (var
));
5128 var
= DECL_VALUE_EXPR (var
);
5129 gcc_assert (TREE_CODE (var
) == INDIRECT_REF
);
5130 var
= TREE_OPERAND (var
, 0);
5131 gcc_assert (DECL_P (var
));
5134 new_var
= lookup_decl (var
, ctx
);
5135 if (var
== OMP_CLAUSE_DECL (c
) && omp_is_reference (var
))
5136 new_var
= build_simple_mem_ref_loc (clause_loc
, new_var
);
5137 ref
= build_outer_var_ref (var
, ctx
, ccode
);
5138 code
= OMP_CLAUSE_REDUCTION_CODE (c
);
5140 /* reduction(-:var) sums up the partial results, so it acts
5141 identically to reduction(+:var). */
5142 if (code
== MINUS_EXPR
)
5147 tree addr
= build_fold_addr_expr_loc (clause_loc
, ref
);
5149 addr
= save_expr (addr
);
5150 ref
= build1 (INDIRECT_REF
, TREE_TYPE (TREE_TYPE (addr
)), addr
);
5151 x
= fold_build2_loc (clause_loc
, code
, TREE_TYPE (ref
), ref
, new_var
);
5152 x
= build2 (OMP_ATOMIC
, void_type_node
, addr
, x
);
5153 gimplify_and_add (x
, stmt_seqp
);
5156 else if (TREE_CODE (OMP_CLAUSE_DECL (c
)) == MEM_REF
)
5158 tree d
= OMP_CLAUSE_DECL (c
);
5159 tree type
= TREE_TYPE (d
);
5160 tree v
= TYPE_MAX_VALUE (TYPE_DOMAIN (type
));
5161 tree i
= create_tmp_var (TREE_TYPE (v
), NULL
);
5162 tree ptype
= build_pointer_type (TREE_TYPE (type
));
5163 tree bias
= TREE_OPERAND (d
, 1);
5164 d
= TREE_OPERAND (d
, 0);
5165 if (TREE_CODE (d
) == POINTER_PLUS_EXPR
)
5167 tree b
= TREE_OPERAND (d
, 1);
5168 b
= maybe_lookup_decl (b
, ctx
);
5171 b
= TREE_OPERAND (d
, 1);
5172 b
= maybe_lookup_decl_in_outer_ctx (b
, ctx
);
5174 if (integer_zerop (bias
))
5178 bias
= fold_convert_loc (clause_loc
, TREE_TYPE (b
), bias
);
5179 bias
= fold_build2_loc (clause_loc
, PLUS_EXPR
,
5180 TREE_TYPE (b
), b
, bias
);
5182 d
= TREE_OPERAND (d
, 0);
5184 /* For ref build_outer_var_ref already performs this, so
5185 only new_var needs a dereference. */
5186 if (TREE_CODE (d
) == INDIRECT_REF
)
5188 new_var
= build_simple_mem_ref_loc (clause_loc
, new_var
);
5189 gcc_assert (omp_is_reference (var
) && var
== orig_var
);
5191 else if (TREE_CODE (d
) == ADDR_EXPR
)
5193 if (orig_var
== var
)
5195 new_var
= build_fold_addr_expr (new_var
);
5196 ref
= build_fold_addr_expr (ref
);
5201 gcc_assert (orig_var
== var
);
5202 if (omp_is_reference (var
))
5203 ref
= build_fold_addr_expr (ref
);
5207 tree t
= maybe_lookup_decl (v
, ctx
);
5211 v
= maybe_lookup_decl_in_outer_ctx (v
, ctx
);
5212 gimplify_expr (&v
, stmt_seqp
, NULL
, is_gimple_val
, fb_rvalue
);
5214 if (!integer_zerop (bias
))
5216 bias
= fold_convert_loc (clause_loc
, sizetype
, bias
);
5217 new_var
= fold_build2_loc (clause_loc
, POINTER_PLUS_EXPR
,
5218 TREE_TYPE (new_var
), new_var
,
5219 unshare_expr (bias
));
5220 ref
= fold_build2_loc (clause_loc
, POINTER_PLUS_EXPR
,
5221 TREE_TYPE (ref
), ref
, bias
);
5223 new_var
= fold_convert_loc (clause_loc
, ptype
, new_var
);
5224 ref
= fold_convert_loc (clause_loc
, ptype
, ref
);
5225 tree m
= create_tmp_var (ptype
, NULL
);
5226 gimplify_assign (m
, new_var
, stmt_seqp
);
5228 m
= create_tmp_var (ptype
, NULL
);
5229 gimplify_assign (m
, ref
, stmt_seqp
);
5231 gimplify_assign (i
, build_int_cst (TREE_TYPE (v
), 0), stmt_seqp
);
5232 tree body
= create_artificial_label (UNKNOWN_LOCATION
);
5233 tree end
= create_artificial_label (UNKNOWN_LOCATION
);
5234 gimple_seq_add_stmt (&sub_seq
, gimple_build_label (body
));
5235 tree priv
= build_simple_mem_ref_loc (clause_loc
, new_var
);
5236 tree out
= build_simple_mem_ref_loc (clause_loc
, ref
);
5237 if (OMP_CLAUSE_REDUCTION_PLACEHOLDER (c
))
5239 tree placeholder
= OMP_CLAUSE_REDUCTION_PLACEHOLDER (c
);
5240 tree decl_placeholder
5241 = OMP_CLAUSE_REDUCTION_DECL_PLACEHOLDER (c
);
5242 SET_DECL_VALUE_EXPR (placeholder
, out
);
5243 DECL_HAS_VALUE_EXPR_P (placeholder
) = 1;
5244 SET_DECL_VALUE_EXPR (decl_placeholder
, priv
);
5245 DECL_HAS_VALUE_EXPR_P (decl_placeholder
) = 1;
5246 lower_omp (&OMP_CLAUSE_REDUCTION_GIMPLE_MERGE (c
), ctx
);
5247 gimple_seq_add_seq (&sub_seq
,
5248 OMP_CLAUSE_REDUCTION_GIMPLE_MERGE (c
));
5249 OMP_CLAUSE_REDUCTION_GIMPLE_MERGE (c
) = NULL
;
5250 OMP_CLAUSE_REDUCTION_PLACEHOLDER (c
) = NULL
;
5251 OMP_CLAUSE_REDUCTION_DECL_PLACEHOLDER (c
) = NULL
;
5255 x
= build2 (code
, TREE_TYPE (out
), out
, priv
);
5256 out
= unshare_expr (out
);
5257 gimplify_assign (out
, x
, &sub_seq
);
5259 gimple
*g
= gimple_build_assign (new_var
, POINTER_PLUS_EXPR
, new_var
,
5260 TYPE_SIZE_UNIT (TREE_TYPE (type
)));
5261 gimple_seq_add_stmt (&sub_seq
, g
);
5262 g
= gimple_build_assign (ref
, POINTER_PLUS_EXPR
, ref
,
5263 TYPE_SIZE_UNIT (TREE_TYPE (type
)));
5264 gimple_seq_add_stmt (&sub_seq
, g
);
5265 g
= gimple_build_assign (i
, PLUS_EXPR
, i
,
5266 build_int_cst (TREE_TYPE (i
), 1));
5267 gimple_seq_add_stmt (&sub_seq
, g
);
5268 g
= gimple_build_cond (LE_EXPR
, i
, v
, body
, end
);
5269 gimple_seq_add_stmt (&sub_seq
, g
);
5270 gimple_seq_add_stmt (&sub_seq
, gimple_build_label (end
));
5272 else if (OMP_CLAUSE_REDUCTION_PLACEHOLDER (c
))
5274 tree placeholder
= OMP_CLAUSE_REDUCTION_PLACEHOLDER (c
);
5276 if (omp_is_reference (var
)
5277 && !useless_type_conversion_p (TREE_TYPE (placeholder
),
5279 ref
= build_fold_addr_expr_loc (clause_loc
, ref
);
5280 SET_DECL_VALUE_EXPR (placeholder
, ref
);
5281 DECL_HAS_VALUE_EXPR_P (placeholder
) = 1;
5282 lower_omp (&OMP_CLAUSE_REDUCTION_GIMPLE_MERGE (c
), ctx
);
5283 gimple_seq_add_seq (&sub_seq
, OMP_CLAUSE_REDUCTION_GIMPLE_MERGE (c
));
5284 OMP_CLAUSE_REDUCTION_GIMPLE_MERGE (c
) = NULL
;
5285 OMP_CLAUSE_REDUCTION_PLACEHOLDER (c
) = NULL
;
5289 x
= build2 (code
, TREE_TYPE (ref
), ref
, new_var
);
5290 ref
= build_outer_var_ref (var
, ctx
);
5291 gimplify_assign (ref
, x
, &sub_seq
);
5295 stmt
= gimple_build_call (builtin_decl_explicit (BUILT_IN_GOMP_ATOMIC_START
),
5297 gimple_seq_add_stmt (stmt_seqp
, stmt
);
5299 gimple_seq_add_seq (stmt_seqp
, sub_seq
);
5301 stmt
= gimple_build_call (builtin_decl_explicit (BUILT_IN_GOMP_ATOMIC_END
),
5303 gimple_seq_add_stmt (stmt_seqp
, stmt
);
5307 /* Generate code to implement the COPYPRIVATE clauses. */
5310 lower_copyprivate_clauses (tree clauses
, gimple_seq
*slist
, gimple_seq
*rlist
,
5315 for (c
= clauses
; c
; c
= OMP_CLAUSE_CHAIN (c
))
5317 tree var
, new_var
, ref
, x
;
5319 location_t clause_loc
= OMP_CLAUSE_LOCATION (c
);
5321 if (OMP_CLAUSE_CODE (c
) != OMP_CLAUSE_COPYPRIVATE
)
5324 var
= OMP_CLAUSE_DECL (c
);
5325 by_ref
= use_pointer_for_field (var
, NULL
);
5327 ref
= build_sender_ref (var
, ctx
);
5328 x
= new_var
= lookup_decl_in_outer_ctx (var
, ctx
);
5331 x
= build_fold_addr_expr_loc (clause_loc
, new_var
);
5332 x
= fold_convert_loc (clause_loc
, TREE_TYPE (ref
), x
);
5334 gimplify_assign (ref
, x
, slist
);
5336 ref
= build_receiver_ref (var
, false, ctx
);
5339 ref
= fold_convert_loc (clause_loc
,
5340 build_pointer_type (TREE_TYPE (new_var
)),
5342 ref
= build_fold_indirect_ref_loc (clause_loc
, ref
);
5344 if (omp_is_reference (var
))
5346 ref
= fold_convert_loc (clause_loc
, TREE_TYPE (new_var
), ref
);
5347 ref
= build_simple_mem_ref_loc (clause_loc
, ref
);
5348 new_var
= build_simple_mem_ref_loc (clause_loc
, new_var
);
5350 x
= lang_hooks
.decls
.omp_clause_assign_op (c
, new_var
, ref
);
5351 gimplify_and_add (x
, rlist
);
5356 /* Generate code to implement the clauses, FIRSTPRIVATE, COPYIN, LASTPRIVATE,
5357 and REDUCTION from the sender (aka parent) side. */
5360 lower_send_clauses (tree clauses
, gimple_seq
*ilist
, gimple_seq
*olist
,
5364 int ignored_looptemp
= 0;
5365 bool is_taskloop
= false;
5367 /* For taskloop, ignore first two _looptemp_ clauses, those are initialized
5368 by GOMP_taskloop. */
5369 if (is_task_ctx (ctx
) && gimple_omp_task_taskloop_p (ctx
->stmt
))
5371 ignored_looptemp
= 2;
5375 for (c
= clauses
; c
; c
= OMP_CLAUSE_CHAIN (c
))
5377 tree val
, ref
, x
, var
;
5378 bool by_ref
, do_in
= false, do_out
= false;
5379 location_t clause_loc
= OMP_CLAUSE_LOCATION (c
);
5381 switch (OMP_CLAUSE_CODE (c
))
5383 case OMP_CLAUSE_PRIVATE
:
5384 if (OMP_CLAUSE_PRIVATE_OUTER_REF (c
))
5387 case OMP_CLAUSE_FIRSTPRIVATE
:
5388 case OMP_CLAUSE_COPYIN
:
5389 case OMP_CLAUSE_LASTPRIVATE
:
5390 case OMP_CLAUSE_REDUCTION
:
5392 case OMP_CLAUSE_SHARED
:
5393 if (OMP_CLAUSE_SHARED_FIRSTPRIVATE (c
))
5396 case OMP_CLAUSE__LOOPTEMP_
:
5397 if (ignored_looptemp
)
5407 val
= OMP_CLAUSE_DECL (c
);
5408 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_REDUCTION
5409 && TREE_CODE (val
) == MEM_REF
)
5411 val
= TREE_OPERAND (val
, 0);
5412 if (TREE_CODE (val
) == POINTER_PLUS_EXPR
)
5413 val
= TREE_OPERAND (val
, 0);
5414 if (TREE_CODE (val
) == INDIRECT_REF
5415 || TREE_CODE (val
) == ADDR_EXPR
)
5416 val
= TREE_OPERAND (val
, 0);
5417 if (is_variable_sized (val
))
5421 /* For OMP_CLAUSE_SHARED_FIRSTPRIVATE, look beyond the
5422 outer taskloop region. */
5423 omp_context
*ctx_for_o
= ctx
;
5425 && OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_SHARED
5426 && OMP_CLAUSE_SHARED_FIRSTPRIVATE (c
))
5427 ctx_for_o
= ctx
->outer
;
5429 var
= lookup_decl_in_outer_ctx (val
, ctx_for_o
);
5431 if (OMP_CLAUSE_CODE (c
) != OMP_CLAUSE_COPYIN
5432 && is_global_var (var
))
5435 t
= omp_member_access_dummy_var (var
);
5438 var
= DECL_VALUE_EXPR (var
);
5439 tree o
= maybe_lookup_decl_in_outer_ctx (t
, ctx_for_o
);
5441 var
= unshare_and_remap (var
, t
, o
);
5443 var
= unshare_expr (var
);
5446 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_SHARED
)
5448 /* Handle taskloop firstprivate/lastprivate, where the
5449 lastprivate on GIMPLE_OMP_TASK is represented as
5450 OMP_CLAUSE_SHARED_FIRSTPRIVATE. */
5451 tree f
= lookup_sfield ((splay_tree_key
) &DECL_UID (val
), ctx
);
5452 x
= omp_build_component_ref (ctx
->sender_decl
, f
);
5453 if (use_pointer_for_field (val
, ctx
))
5454 var
= build_fold_addr_expr (var
);
5455 gimplify_assign (x
, var
, ilist
);
5456 DECL_ABSTRACT_ORIGIN (f
) = NULL
;
5460 if ((OMP_CLAUSE_CODE (c
) != OMP_CLAUSE_REDUCTION
5461 || val
== OMP_CLAUSE_DECL (c
))
5462 && is_variable_sized (val
))
5464 by_ref
= use_pointer_for_field (val
, NULL
);
5466 switch (OMP_CLAUSE_CODE (c
))
5468 case OMP_CLAUSE_FIRSTPRIVATE
:
5469 if (OMP_CLAUSE_FIRSTPRIVATE_IMPLICIT (c
)
5471 && is_task_ctx (ctx
))
5472 TREE_NO_WARNING (var
) = 1;
5476 case OMP_CLAUSE_PRIVATE
:
5477 case OMP_CLAUSE_COPYIN
:
5478 case OMP_CLAUSE__LOOPTEMP_
:
5482 case OMP_CLAUSE_LASTPRIVATE
:
5483 if (by_ref
|| omp_is_reference (val
))
5485 if (OMP_CLAUSE_LASTPRIVATE_FIRSTPRIVATE (c
))
5492 if (lang_hooks
.decls
.omp_private_outer_ref (val
))
5497 case OMP_CLAUSE_REDUCTION
:
5499 if (val
== OMP_CLAUSE_DECL (c
))
5500 do_out
= !(by_ref
|| omp_is_reference (val
));
5502 by_ref
= TREE_CODE (TREE_TYPE (val
)) == ARRAY_TYPE
;
5511 ref
= build_sender_ref (val
, ctx
);
5512 x
= by_ref
? build_fold_addr_expr_loc (clause_loc
, var
) : var
;
5513 gimplify_assign (ref
, x
, ilist
);
5514 if (is_task_ctx (ctx
))
5515 DECL_ABSTRACT_ORIGIN (TREE_OPERAND (ref
, 1)) = NULL
;
5520 ref
= build_sender_ref (val
, ctx
);
5521 gimplify_assign (var
, ref
, olist
);
5526 /* Generate code to implement SHARED from the sender (aka parent)
5527 side. This is trickier, since GIMPLE_OMP_PARALLEL_CLAUSES doesn't
5528 list things that got automatically shared. */
5531 lower_send_shared_vars (gimple_seq
*ilist
, gimple_seq
*olist
, omp_context
*ctx
)
5533 tree var
, ovar
, nvar
, t
, f
, x
, record_type
;
5535 if (ctx
->record_type
== NULL
)
5538 record_type
= ctx
->srecord_type
? ctx
->srecord_type
: ctx
->record_type
;
5539 for (f
= TYPE_FIELDS (record_type
); f
; f
= DECL_CHAIN (f
))
5541 ovar
= DECL_ABSTRACT_ORIGIN (f
);
5542 if (!ovar
|| TREE_CODE (ovar
) == FIELD_DECL
)
5545 nvar
= maybe_lookup_decl (ovar
, ctx
);
5546 if (!nvar
|| !DECL_HAS_VALUE_EXPR_P (nvar
))
5549 /* If CTX is a nested parallel directive. Find the immediately
5550 enclosing parallel or workshare construct that contains a
5551 mapping for OVAR. */
5552 var
= lookup_decl_in_outer_ctx (ovar
, ctx
);
5554 t
= omp_member_access_dummy_var (var
);
5557 var
= DECL_VALUE_EXPR (var
);
5558 tree o
= maybe_lookup_decl_in_outer_ctx (t
, ctx
);
5560 var
= unshare_and_remap (var
, t
, o
);
5562 var
= unshare_expr (var
);
5565 if (use_pointer_for_field (ovar
, ctx
))
5567 x
= build_sender_ref (ovar
, ctx
);
5568 var
= build_fold_addr_expr (var
);
5569 gimplify_assign (x
, var
, ilist
);
5573 x
= build_sender_ref (ovar
, ctx
);
5574 gimplify_assign (x
, var
, ilist
);
5576 if (!TREE_READONLY (var
)
5577 /* We don't need to receive a new reference to a result
5578 or parm decl. In fact we may not store to it as we will
5579 invalidate any pending RSO and generate wrong gimple
5581 && !((TREE_CODE (var
) == RESULT_DECL
5582 || TREE_CODE (var
) == PARM_DECL
)
5583 && DECL_BY_REFERENCE (var
)))
5585 x
= build_sender_ref (ovar
, ctx
);
5586 gimplify_assign (var
, x
, olist
);
5592 /* Emit an OpenACC head marker call, encapulating the partitioning and
5593 other information that must be processed by the target compiler.
5594 Return the maximum number of dimensions the associated loop might
5595 be partitioned over. */
5598 lower_oacc_head_mark (location_t loc
, tree ddvar
, tree clauses
,
5599 gimple_seq
*seq
, omp_context
*ctx
)
5601 unsigned levels
= 0;
5603 tree gang_static
= NULL_TREE
;
5604 auto_vec
<tree
, 5> args
;
5606 args
.quick_push (build_int_cst
5607 (integer_type_node
, IFN_UNIQUE_OACC_HEAD_MARK
));
5608 args
.quick_push (ddvar
);
5609 for (tree c
= clauses
; c
; c
= OMP_CLAUSE_CHAIN (c
))
5611 switch (OMP_CLAUSE_CODE (c
))
5613 case OMP_CLAUSE_GANG
:
5614 tag
|= OLF_DIM_GANG
;
5615 gang_static
= OMP_CLAUSE_GANG_STATIC_EXPR (c
);
5616 /* static:* is represented by -1, and we can ignore it, as
5617 scheduling is always static. */
5618 if (gang_static
&& integer_minus_onep (gang_static
))
5619 gang_static
= NULL_TREE
;
5623 case OMP_CLAUSE_WORKER
:
5624 tag
|= OLF_DIM_WORKER
;
5628 case OMP_CLAUSE_VECTOR
:
5629 tag
|= OLF_DIM_VECTOR
;
5633 case OMP_CLAUSE_SEQ
:
5637 case OMP_CLAUSE_AUTO
:
5641 case OMP_CLAUSE_INDEPENDENT
:
5642 tag
|= OLF_INDEPENDENT
;
5645 case OMP_CLAUSE_TILE
:
5656 if (DECL_P (gang_static
))
5657 gang_static
= build_outer_var_ref (gang_static
, ctx
);
5658 tag
|= OLF_GANG_STATIC
;
5661 /* In a parallel region, loops are implicitly INDEPENDENT. */
5662 omp_context
*tgt
= enclosing_target_ctx (ctx
);
5663 if (!tgt
|| is_oacc_parallel (tgt
))
5664 tag
|= OLF_INDEPENDENT
;
5667 /* Tiling could use all 3 levels. */
5671 /* A loop lacking SEQ, GANG, WORKER and/or VECTOR could be AUTO.
5672 Ensure at least one level, or 2 for possible auto
5674 bool maybe_auto
= !(tag
& (((GOMP_DIM_MASK (GOMP_DIM_MAX
) - 1)
5675 << OLF_DIM_BASE
) | OLF_SEQ
));
5677 if (levels
< 1u + maybe_auto
)
5678 levels
= 1u + maybe_auto
;
5681 args
.quick_push (build_int_cst (integer_type_node
, levels
));
5682 args
.quick_push (build_int_cst (integer_type_node
, tag
));
5684 args
.quick_push (gang_static
);
5686 gcall
*call
= gimple_build_call_internal_vec (IFN_UNIQUE
, args
);
5687 gimple_set_location (call
, loc
);
5688 gimple_set_lhs (call
, ddvar
);
5689 gimple_seq_add_stmt (seq
, call
);
5694 /* Emit an OpenACC lopp head or tail marker to SEQ. LEVEL is the
5695 partitioning level of the enclosed region. */
5698 lower_oacc_loop_marker (location_t loc
, tree ddvar
, bool head
,
5699 tree tofollow
, gimple_seq
*seq
)
5701 int marker_kind
= (head
? IFN_UNIQUE_OACC_HEAD_MARK
5702 : IFN_UNIQUE_OACC_TAIL_MARK
);
5703 tree marker
= build_int_cst (integer_type_node
, marker_kind
);
5704 int nargs
= 2 + (tofollow
!= NULL_TREE
);
5705 gcall
*call
= gimple_build_call_internal (IFN_UNIQUE
, nargs
,
5706 marker
, ddvar
, tofollow
);
5707 gimple_set_location (call
, loc
);
5708 gimple_set_lhs (call
, ddvar
);
5709 gimple_seq_add_stmt (seq
, call
);
5712 /* Generate the before and after OpenACC loop sequences. CLAUSES are
5713 the loop clauses, from which we extract reductions. Initialize
5717 lower_oacc_head_tail (location_t loc
, tree clauses
,
5718 gimple_seq
*head
, gimple_seq
*tail
, omp_context
*ctx
)
5721 tree ddvar
= create_tmp_var (integer_type_node
, ".data_dep");
5722 gimple_seq_add_stmt (head
, gimple_build_assign (ddvar
, integer_zero_node
));
5724 unsigned count
= lower_oacc_head_mark (loc
, ddvar
, clauses
, head
, ctx
);
5725 tree fork_kind
= build_int_cst (unsigned_type_node
, IFN_UNIQUE_OACC_FORK
);
5726 tree join_kind
= build_int_cst (unsigned_type_node
, IFN_UNIQUE_OACC_JOIN
);
5729 for (unsigned done
= 1; count
; count
--, done
++)
5731 gimple_seq fork_seq
= NULL
;
5732 gimple_seq join_seq
= NULL
;
5734 tree place
= build_int_cst (integer_type_node
, -1);
5735 gcall
*fork
= gimple_build_call_internal (IFN_UNIQUE
, 3,
5736 fork_kind
, ddvar
, place
);
5737 gimple_set_location (fork
, loc
);
5738 gimple_set_lhs (fork
, ddvar
);
5740 gcall
*join
= gimple_build_call_internal (IFN_UNIQUE
, 3,
5741 join_kind
, ddvar
, place
);
5742 gimple_set_location (join
, loc
);
5743 gimple_set_lhs (join
, ddvar
);
5745 /* Mark the beginning of this level sequence. */
5747 lower_oacc_loop_marker (loc
, ddvar
, true,
5748 build_int_cst (integer_type_node
, count
),
5750 lower_oacc_loop_marker (loc
, ddvar
, false,
5751 build_int_cst (integer_type_node
, done
),
5754 lower_oacc_reductions (loc
, clauses
, place
, inner
,
5755 fork
, join
, &fork_seq
, &join_seq
, ctx
);
5757 /* Append this level to head. */
5758 gimple_seq_add_seq (head
, fork_seq
);
5759 /* Prepend it to tail. */
5760 gimple_seq_add_seq (&join_seq
, *tail
);
5766 /* Mark the end of the sequence. */
5767 lower_oacc_loop_marker (loc
, ddvar
, true, NULL_TREE
, head
);
5768 lower_oacc_loop_marker (loc
, ddvar
, false, NULL_TREE
, tail
);
5771 /* If exceptions are enabled, wrap the statements in BODY in a MUST_NOT_THROW
5772 catch handler and return it. This prevents programs from violating the
5773 structured block semantics with throws. */
5776 maybe_catch_exception (gimple_seq body
)
5781 if (!flag_exceptions
)
5784 if (lang_hooks
.eh_protect_cleanup_actions
!= NULL
)
5785 decl
= lang_hooks
.eh_protect_cleanup_actions ();
5787 decl
= builtin_decl_explicit (BUILT_IN_TRAP
);
5789 g
= gimple_build_eh_must_not_throw (decl
);
5790 g
= gimple_build_try (body
, gimple_seq_alloc_with_stmt (g
),
5793 return gimple_seq_alloc_with_stmt (g
);
5797 /* Routines to lower OMP directives into OMP-GIMPLE. */
5799 /* If ctx is a worksharing context inside of a cancellable parallel
5800 region and it isn't nowait, add lhs to its GIMPLE_OMP_RETURN
5801 and conditional branch to parallel's cancel_label to handle
5802 cancellation in the implicit barrier. */
5805 maybe_add_implicit_barrier_cancel (omp_context
*ctx
, gimple_seq
*body
)
5807 gimple
*omp_return
= gimple_seq_last_stmt (*body
);
5808 gcc_assert (gimple_code (omp_return
) == GIMPLE_OMP_RETURN
);
5809 if (gimple_omp_return_nowait_p (omp_return
))
5812 && gimple_code (ctx
->outer
->stmt
) == GIMPLE_OMP_PARALLEL
5813 && ctx
->outer
->cancellable
)
5815 tree fndecl
= builtin_decl_explicit (BUILT_IN_GOMP_CANCEL
);
5816 tree c_bool_type
= TREE_TYPE (TREE_TYPE (fndecl
));
5817 tree lhs
= create_tmp_var (c_bool_type
);
5818 gimple_omp_return_set_lhs (omp_return
, lhs
);
5819 tree fallthru_label
= create_artificial_label (UNKNOWN_LOCATION
);
5820 gimple
*g
= gimple_build_cond (NE_EXPR
, lhs
,
5821 fold_convert (c_bool_type
,
5822 boolean_false_node
),
5823 ctx
->outer
->cancel_label
, fallthru_label
);
5824 gimple_seq_add_stmt (body
, g
);
5825 gimple_seq_add_stmt (body
, gimple_build_label (fallthru_label
));
5829 /* Lower the OpenMP sections directive in the current statement in GSI_P.
5830 CTX is the enclosing OMP context for the current statement. */
5833 lower_omp_sections (gimple_stmt_iterator
*gsi_p
, omp_context
*ctx
)
5835 tree block
, control
;
5836 gimple_stmt_iterator tgsi
;
5837 gomp_sections
*stmt
;
5839 gbind
*new_stmt
, *bind
;
5840 gimple_seq ilist
, dlist
, olist
, new_body
;
5842 stmt
= as_a
<gomp_sections
*> (gsi_stmt (*gsi_p
));
5844 push_gimplify_context ();
5848 lower_rec_input_clauses (gimple_omp_sections_clauses (stmt
),
5849 &ilist
, &dlist
, ctx
, NULL
);
5851 new_body
= gimple_omp_body (stmt
);
5852 gimple_omp_set_body (stmt
, NULL
);
5853 tgsi
= gsi_start (new_body
);
5854 for (; !gsi_end_p (tgsi
); gsi_next (&tgsi
))
5859 sec_start
= gsi_stmt (tgsi
);
5860 sctx
= maybe_lookup_ctx (sec_start
);
5863 lower_omp (gimple_omp_body_ptr (sec_start
), sctx
);
5864 gsi_insert_seq_after (&tgsi
, gimple_omp_body (sec_start
),
5865 GSI_CONTINUE_LINKING
);
5866 gimple_omp_set_body (sec_start
, NULL
);
5868 if (gsi_one_before_end_p (tgsi
))
5870 gimple_seq l
= NULL
;
5871 lower_lastprivate_clauses (gimple_omp_sections_clauses (stmt
), NULL
,
5873 gsi_insert_seq_after (&tgsi
, l
, GSI_CONTINUE_LINKING
);
5874 gimple_omp_section_set_last (sec_start
);
5877 gsi_insert_after (&tgsi
, gimple_build_omp_return (false),
5878 GSI_CONTINUE_LINKING
);
5881 block
= make_node (BLOCK
);
5882 bind
= gimple_build_bind (NULL
, new_body
, block
);
5885 lower_reduction_clauses (gimple_omp_sections_clauses (stmt
), &olist
, ctx
);
5887 block
= make_node (BLOCK
);
5888 new_stmt
= gimple_build_bind (NULL
, NULL
, block
);
5889 gsi_replace (gsi_p
, new_stmt
, true);
5891 pop_gimplify_context (new_stmt
);
5892 gimple_bind_append_vars (new_stmt
, ctx
->block_vars
);
5893 BLOCK_VARS (block
) = gimple_bind_vars (bind
);
5894 if (BLOCK_VARS (block
))
5895 TREE_USED (block
) = 1;
5898 gimple_seq_add_seq (&new_body
, ilist
);
5899 gimple_seq_add_stmt (&new_body
, stmt
);
5900 gimple_seq_add_stmt (&new_body
, gimple_build_omp_sections_switch ());
5901 gimple_seq_add_stmt (&new_body
, bind
);
5903 control
= create_tmp_var (unsigned_type_node
, ".section");
5904 t
= gimple_build_omp_continue (control
, control
);
5905 gimple_omp_sections_set_control (stmt
, control
);
5906 gimple_seq_add_stmt (&new_body
, t
);
5908 gimple_seq_add_seq (&new_body
, olist
);
5909 if (ctx
->cancellable
)
5910 gimple_seq_add_stmt (&new_body
, gimple_build_label (ctx
->cancel_label
));
5911 gimple_seq_add_seq (&new_body
, dlist
);
5913 new_body
= maybe_catch_exception (new_body
);
5915 bool nowait
= omp_find_clause (gimple_omp_sections_clauses (stmt
),
5916 OMP_CLAUSE_NOWAIT
) != NULL_TREE
;
5917 t
= gimple_build_omp_return (nowait
);
5918 gimple_seq_add_stmt (&new_body
, t
);
5919 maybe_add_implicit_barrier_cancel (ctx
, &new_body
);
5921 gimple_bind_set_body (new_stmt
, new_body
);
5925 /* A subroutine of lower_omp_single. Expand the simple form of
5926 a GIMPLE_OMP_SINGLE, without a copyprivate clause:
5928 if (GOMP_single_start ())
5930 [ GOMP_barrier (); ] -> unless 'nowait' is present.
5932 FIXME. It may be better to delay expanding the logic of this until
5933 pass_expand_omp. The expanded logic may make the job more difficult
5934 to a synchronization analysis pass. */
5937 lower_omp_single_simple (gomp_single
*single_stmt
, gimple_seq
*pre_p
)
5939 location_t loc
= gimple_location (single_stmt
);
5940 tree tlabel
= create_artificial_label (loc
);
5941 tree flabel
= create_artificial_label (loc
);
5942 gimple
*call
, *cond
;
5945 decl
= builtin_decl_explicit (BUILT_IN_GOMP_SINGLE_START
);
5946 lhs
= create_tmp_var (TREE_TYPE (TREE_TYPE (decl
)));
5947 call
= gimple_build_call (decl
, 0);
5948 gimple_call_set_lhs (call
, lhs
);
5949 gimple_seq_add_stmt (pre_p
, call
);
5951 cond
= gimple_build_cond (EQ_EXPR
, lhs
,
5952 fold_convert_loc (loc
, TREE_TYPE (lhs
),
5955 gimple_seq_add_stmt (pre_p
, cond
);
5956 gimple_seq_add_stmt (pre_p
, gimple_build_label (tlabel
));
5957 gimple_seq_add_seq (pre_p
, gimple_omp_body (single_stmt
));
5958 gimple_seq_add_stmt (pre_p
, gimple_build_label (flabel
));
5962 /* A subroutine of lower_omp_single. Expand the simple form of
5963 a GIMPLE_OMP_SINGLE, with a copyprivate clause:
5965 #pragma omp single copyprivate (a, b, c)
5967 Create a new structure to hold copies of 'a', 'b' and 'c' and emit:
5970 if ((copyout_p = GOMP_single_copy_start ()) == NULL)
5976 GOMP_single_copy_end (©out);
5987 FIXME. It may be better to delay expanding the logic of this until
5988 pass_expand_omp. The expanded logic may make the job more difficult
5989 to a synchronization analysis pass. */
5992 lower_omp_single_copy (gomp_single
*single_stmt
, gimple_seq
*pre_p
,
5995 tree ptr_type
, t
, l0
, l1
, l2
, bfn_decl
;
5996 gimple_seq copyin_seq
;
5997 location_t loc
= gimple_location (single_stmt
);
5999 ctx
->sender_decl
= create_tmp_var (ctx
->record_type
, ".omp_copy_o");
6001 ptr_type
= build_pointer_type (ctx
->record_type
);
6002 ctx
->receiver_decl
= create_tmp_var (ptr_type
, ".omp_copy_i");
6004 l0
= create_artificial_label (loc
);
6005 l1
= create_artificial_label (loc
);
6006 l2
= create_artificial_label (loc
);
6008 bfn_decl
= builtin_decl_explicit (BUILT_IN_GOMP_SINGLE_COPY_START
);
6009 t
= build_call_expr_loc (loc
, bfn_decl
, 0);
6010 t
= fold_convert_loc (loc
, ptr_type
, t
);
6011 gimplify_assign (ctx
->receiver_decl
, t
, pre_p
);
6013 t
= build2 (EQ_EXPR
, boolean_type_node
, ctx
->receiver_decl
,
6014 build_int_cst (ptr_type
, 0));
6015 t
= build3 (COND_EXPR
, void_type_node
, t
,
6016 build_and_jump (&l0
), build_and_jump (&l1
));
6017 gimplify_and_add (t
, pre_p
);
6019 gimple_seq_add_stmt (pre_p
, gimple_build_label (l0
));
6021 gimple_seq_add_seq (pre_p
, gimple_omp_body (single_stmt
));
6024 lower_copyprivate_clauses (gimple_omp_single_clauses (single_stmt
), pre_p
,
6027 t
= build_fold_addr_expr_loc (loc
, ctx
->sender_decl
);
6028 bfn_decl
= builtin_decl_explicit (BUILT_IN_GOMP_SINGLE_COPY_END
);
6029 t
= build_call_expr_loc (loc
, bfn_decl
, 1, t
);
6030 gimplify_and_add (t
, pre_p
);
6032 t
= build_and_jump (&l2
);
6033 gimplify_and_add (t
, pre_p
);
6035 gimple_seq_add_stmt (pre_p
, gimple_build_label (l1
));
6037 gimple_seq_add_seq (pre_p
, copyin_seq
);
6039 gimple_seq_add_stmt (pre_p
, gimple_build_label (l2
));
6043 /* Expand code for an OpenMP single directive. */
6046 lower_omp_single (gimple_stmt_iterator
*gsi_p
, omp_context
*ctx
)
6049 gomp_single
*single_stmt
= as_a
<gomp_single
*> (gsi_stmt (*gsi_p
));
6051 gimple_seq bind_body
, bind_body_tail
= NULL
, dlist
;
6053 push_gimplify_context ();
6055 block
= make_node (BLOCK
);
6056 bind
= gimple_build_bind (NULL
, NULL
, block
);
6057 gsi_replace (gsi_p
, bind
, true);
6060 lower_rec_input_clauses (gimple_omp_single_clauses (single_stmt
),
6061 &bind_body
, &dlist
, ctx
, NULL
);
6062 lower_omp (gimple_omp_body_ptr (single_stmt
), ctx
);
6064 gimple_seq_add_stmt (&bind_body
, single_stmt
);
6066 if (ctx
->record_type
)
6067 lower_omp_single_copy (single_stmt
, &bind_body
, ctx
);
6069 lower_omp_single_simple (single_stmt
, &bind_body
);
6071 gimple_omp_set_body (single_stmt
, NULL
);
6073 gimple_seq_add_seq (&bind_body
, dlist
);
6075 bind_body
= maybe_catch_exception (bind_body
);
6077 bool nowait
= omp_find_clause (gimple_omp_single_clauses (single_stmt
),
6078 OMP_CLAUSE_NOWAIT
) != NULL_TREE
;
6079 gimple
*g
= gimple_build_omp_return (nowait
);
6080 gimple_seq_add_stmt (&bind_body_tail
, g
);
6081 maybe_add_implicit_barrier_cancel (ctx
, &bind_body_tail
);
6082 if (ctx
->record_type
)
6084 gimple_stmt_iterator gsi
= gsi_start (bind_body_tail
);
6085 tree clobber
= build_constructor (ctx
->record_type
, NULL
);
6086 TREE_THIS_VOLATILE (clobber
) = 1;
6087 gsi_insert_after (&gsi
, gimple_build_assign (ctx
->sender_decl
,
6088 clobber
), GSI_SAME_STMT
);
6090 gimple_seq_add_seq (&bind_body
, bind_body_tail
);
6091 gimple_bind_set_body (bind
, bind_body
);
6093 pop_gimplify_context (bind
);
6095 gimple_bind_append_vars (bind
, ctx
->block_vars
);
6096 BLOCK_VARS (block
) = ctx
->block_vars
;
6097 if (BLOCK_VARS (block
))
6098 TREE_USED (block
) = 1;
6102 /* Expand code for an OpenMP master directive. */
6105 lower_omp_master (gimple_stmt_iterator
*gsi_p
, omp_context
*ctx
)
6107 tree block
, lab
= NULL
, x
, bfn_decl
;
6108 gimple
*stmt
= gsi_stmt (*gsi_p
);
6110 location_t loc
= gimple_location (stmt
);
6113 push_gimplify_context ();
6115 block
= make_node (BLOCK
);
6116 bind
= gimple_build_bind (NULL
, NULL
, block
);
6117 gsi_replace (gsi_p
, bind
, true);
6118 gimple_bind_add_stmt (bind
, stmt
);
6120 bfn_decl
= builtin_decl_explicit (BUILT_IN_OMP_GET_THREAD_NUM
);
6121 x
= build_call_expr_loc (loc
, bfn_decl
, 0);
6122 x
= build2 (EQ_EXPR
, boolean_type_node
, x
, integer_zero_node
);
6123 x
= build3 (COND_EXPR
, void_type_node
, x
, NULL
, build_and_jump (&lab
));
6125 gimplify_and_add (x
, &tseq
);
6126 gimple_bind_add_seq (bind
, tseq
);
6128 lower_omp (gimple_omp_body_ptr (stmt
), ctx
);
6129 gimple_omp_set_body (stmt
, maybe_catch_exception (gimple_omp_body (stmt
)));
6130 gimple_bind_add_seq (bind
, gimple_omp_body (stmt
));
6131 gimple_omp_set_body (stmt
, NULL
);
6133 gimple_bind_add_stmt (bind
, gimple_build_label (lab
));
6135 gimple_bind_add_stmt (bind
, gimple_build_omp_return (true));
6137 pop_gimplify_context (bind
);
6139 gimple_bind_append_vars (bind
, ctx
->block_vars
);
6140 BLOCK_VARS (block
) = ctx
->block_vars
;
6144 /* Expand code for an OpenMP taskgroup directive. */
6147 lower_omp_taskgroup (gimple_stmt_iterator
*gsi_p
, omp_context
*ctx
)
6149 gimple
*stmt
= gsi_stmt (*gsi_p
);
6152 tree block
= make_node (BLOCK
);
6154 bind
= gimple_build_bind (NULL
, NULL
, block
);
6155 gsi_replace (gsi_p
, bind
, true);
6156 gimple_bind_add_stmt (bind
, stmt
);
6158 x
= gimple_build_call (builtin_decl_explicit (BUILT_IN_GOMP_TASKGROUP_START
),
6160 gimple_bind_add_stmt (bind
, x
);
6162 lower_omp (gimple_omp_body_ptr (stmt
), ctx
);
6163 gimple_bind_add_seq (bind
, gimple_omp_body (stmt
));
6164 gimple_omp_set_body (stmt
, NULL
);
6166 gimple_bind_add_stmt (bind
, gimple_build_omp_return (true));
6168 gimple_bind_append_vars (bind
, ctx
->block_vars
);
6169 BLOCK_VARS (block
) = ctx
->block_vars
;
6173 /* Fold the OMP_ORDERED_CLAUSES for the OMP_ORDERED in STMT if possible. */
6176 lower_omp_ordered_clauses (gimple_stmt_iterator
*gsi_p
, gomp_ordered
*ord_stmt
,
6179 struct omp_for_data fd
;
6180 if (!ctx
->outer
|| gimple_code (ctx
->outer
->stmt
) != GIMPLE_OMP_FOR
)
6183 unsigned int len
= gimple_omp_for_collapse (ctx
->outer
->stmt
);
6184 struct omp_for_data_loop
*loops
= XALLOCAVEC (struct omp_for_data_loop
, len
);
6185 omp_extract_for_data (as_a
<gomp_for
*> (ctx
->outer
->stmt
), &fd
, loops
);
6189 tree
*list_p
= gimple_omp_ordered_clauses_ptr (ord_stmt
);
6190 tree c
= gimple_omp_ordered_clauses (ord_stmt
);
6191 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_DEPEND
6192 && OMP_CLAUSE_DEPEND_KIND (c
) == OMP_CLAUSE_DEPEND_SINK
)
6194 /* Merge depend clauses from multiple adjacent
6195 #pragma omp ordered depend(sink:...) constructs
6196 into one #pragma omp ordered depend(sink:...), so that
6197 we can optimize them together. */
6198 gimple_stmt_iterator gsi
= *gsi_p
;
6200 while (!gsi_end_p (gsi
))
6202 gimple
*stmt
= gsi_stmt (gsi
);
6203 if (is_gimple_debug (stmt
)
6204 || gimple_code (stmt
) == GIMPLE_NOP
)
6209 if (gimple_code (stmt
) != GIMPLE_OMP_ORDERED
)
6211 gomp_ordered
*ord_stmt2
= as_a
<gomp_ordered
*> (stmt
);
6212 c
= gimple_omp_ordered_clauses (ord_stmt2
);
6214 || OMP_CLAUSE_CODE (c
) != OMP_CLAUSE_DEPEND
6215 || OMP_CLAUSE_DEPEND_KIND (c
) != OMP_CLAUSE_DEPEND_SINK
)
6218 list_p
= &OMP_CLAUSE_CHAIN (*list_p
);
6220 gsi_remove (&gsi
, true);
6224 /* Canonicalize sink dependence clauses into one folded clause if
6227 The basic algorithm is to create a sink vector whose first
6228 element is the GCD of all the first elements, and whose remaining
6229 elements are the minimum of the subsequent columns.
6231 We ignore dependence vectors whose first element is zero because
6232 such dependencies are known to be executed by the same thread.
6234 We take into account the direction of the loop, so a minimum
6235 becomes a maximum if the loop is iterating forwards. We also
6236 ignore sink clauses where the loop direction is unknown, or where
6237 the offsets are clearly invalid because they are not a multiple
6238 of the loop increment.
6242 #pragma omp for ordered(2)
6243 for (i=0; i < N; ++i)
6244 for (j=0; j < M; ++j)
6246 #pragma omp ordered \
6247 depend(sink:i-8,j-2) \
6248 depend(sink:i,j-1) \ // Completely ignored because i+0.
6249 depend(sink:i-4,j-3) \
6250 depend(sink:i-6,j-4)
6251 #pragma omp ordered depend(source)
6256 depend(sink:-gcd(8,4,6),-min(2,3,4))
6261 /* FIXME: Computing GCD's where the first element is zero is
6262 non-trivial in the presence of collapsed loops. Do this later. */
6263 if (fd
.collapse
> 1)
6266 wide_int
*folded_deps
= XALLOCAVEC (wide_int
, 2 * len
- 1);
6268 /* wide_int is not a POD so it must be default-constructed. */
6269 for (unsigned i
= 0; i
!= 2 * len
- 1; ++i
)
6270 new (static_cast<void*>(folded_deps
+ i
)) wide_int ();
6272 tree folded_dep
= NULL_TREE
;
6273 /* TRUE if the first dimension's offset is negative. */
6274 bool neg_offset_p
= false;
6276 list_p
= gimple_omp_ordered_clauses_ptr (ord_stmt
);
6278 while ((c
= *list_p
) != NULL
)
6280 bool remove
= false;
6282 gcc_assert (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_DEPEND
);
6283 if (OMP_CLAUSE_DEPEND_KIND (c
) != OMP_CLAUSE_DEPEND_SINK
)
6284 goto next_ordered_clause
;
6287 for (vec
= OMP_CLAUSE_DECL (c
), i
= 0;
6288 vec
&& TREE_CODE (vec
) == TREE_LIST
;
6289 vec
= TREE_CHAIN (vec
), ++i
)
6291 gcc_assert (i
< len
);
6293 /* omp_extract_for_data has canonicalized the condition. */
6294 gcc_assert (fd
.loops
[i
].cond_code
== LT_EXPR
6295 || fd
.loops
[i
].cond_code
== GT_EXPR
);
6296 bool forward
= fd
.loops
[i
].cond_code
== LT_EXPR
;
6297 bool maybe_lexically_later
= true;
6299 /* While the committee makes up its mind, bail if we have any
6300 non-constant steps. */
6301 if (TREE_CODE (fd
.loops
[i
].step
) != INTEGER_CST
)
6302 goto lower_omp_ordered_ret
;
6304 tree itype
= TREE_TYPE (TREE_VALUE (vec
));
6305 if (POINTER_TYPE_P (itype
))
6307 wide_int offset
= wide_int::from (wi::to_wide (TREE_PURPOSE (vec
)),
6308 TYPE_PRECISION (itype
),
6311 /* Ignore invalid offsets that are not multiples of the step. */
6312 if (!wi::multiple_of_p (wi::abs (offset
),
6313 wi::abs (wi::to_wide (fd
.loops
[i
].step
)),
6316 warning_at (OMP_CLAUSE_LOCATION (c
), 0,
6317 "ignoring sink clause with offset that is not "
6318 "a multiple of the loop step");
6320 goto next_ordered_clause
;
6323 /* Calculate the first dimension. The first dimension of
6324 the folded dependency vector is the GCD of the first
6325 elements, while ignoring any first elements whose offset
6329 /* Ignore dependence vectors whose first dimension is 0. */
6333 goto next_ordered_clause
;
6337 if (!TYPE_UNSIGNED (itype
) && (forward
^ wi::neg_p (offset
)))
6339 error_at (OMP_CLAUSE_LOCATION (c
),
6340 "first offset must be in opposite direction "
6341 "of loop iterations");
6342 goto lower_omp_ordered_ret
;
6346 neg_offset_p
= forward
;
6347 /* Initialize the first time around. */
6348 if (folded_dep
== NULL_TREE
)
6351 folded_deps
[0] = offset
;
6354 folded_deps
[0] = wi::gcd (folded_deps
[0],
6358 /* Calculate minimum for the remaining dimensions. */
6361 folded_deps
[len
+ i
- 1] = offset
;
6362 if (folded_dep
== c
)
6363 folded_deps
[i
] = offset
;
6364 else if (maybe_lexically_later
6365 && !wi::eq_p (folded_deps
[i
], offset
))
6367 if (forward
^ wi::gts_p (folded_deps
[i
], offset
))
6371 for (j
= 1; j
<= i
; j
++)
6372 folded_deps
[j
] = folded_deps
[len
+ j
- 1];
6375 maybe_lexically_later
= false;
6379 gcc_assert (i
== len
);
6383 next_ordered_clause
:
6385 *list_p
= OMP_CLAUSE_CHAIN (c
);
6387 list_p
= &OMP_CLAUSE_CHAIN (c
);
6393 folded_deps
[0] = -folded_deps
[0];
6395 tree itype
= TREE_TYPE (TREE_VALUE (OMP_CLAUSE_DECL (folded_dep
)));
6396 if (POINTER_TYPE_P (itype
))
6399 TREE_PURPOSE (OMP_CLAUSE_DECL (folded_dep
))
6400 = wide_int_to_tree (itype
, folded_deps
[0]);
6401 OMP_CLAUSE_CHAIN (folded_dep
) = gimple_omp_ordered_clauses (ord_stmt
);
6402 *gimple_omp_ordered_clauses_ptr (ord_stmt
) = folded_dep
;
6405 lower_omp_ordered_ret
:
6407 /* Ordered without clauses is #pragma omp threads, while we want
6408 a nop instead if we remove all clauses. */
6409 if (gimple_omp_ordered_clauses (ord_stmt
) == NULL_TREE
)
6410 gsi_replace (gsi_p
, gimple_build_nop (), true);
6414 /* Expand code for an OpenMP ordered directive. */
6417 lower_omp_ordered (gimple_stmt_iterator
*gsi_p
, omp_context
*ctx
)
6420 gimple
*stmt
= gsi_stmt (*gsi_p
), *g
;
6421 gomp_ordered
*ord_stmt
= as_a
<gomp_ordered
*> (stmt
);
6424 bool simd
= omp_find_clause (gimple_omp_ordered_clauses (ord_stmt
),
6426 /* FIXME: this should check presence of OMP_CLAUSE__SIMT_ on the enclosing
6429 = simd
&& omp_maybe_offloaded_ctx (ctx
) && omp_max_simt_vf () > 1;
6430 bool threads
= omp_find_clause (gimple_omp_ordered_clauses (ord_stmt
),
6431 OMP_CLAUSE_THREADS
);
6433 if (omp_find_clause (gimple_omp_ordered_clauses (ord_stmt
),
6436 /* FIXME: This is needs to be moved to the expansion to verify various
6437 conditions only testable on cfg with dominators computed, and also
6438 all the depend clauses to be merged still might need to be available
6439 for the runtime checks. */
6441 lower_omp_ordered_clauses (gsi_p
, ord_stmt
, ctx
);
6445 push_gimplify_context ();
6447 block
= make_node (BLOCK
);
6448 bind
= gimple_build_bind (NULL
, NULL
, block
);
6449 gsi_replace (gsi_p
, bind
, true);
6450 gimple_bind_add_stmt (bind
, stmt
);
6454 x
= gimple_build_call_internal (IFN_GOMP_SIMD_ORDERED_START
, 1,
6455 build_int_cst (NULL_TREE
, threads
));
6456 cfun
->has_simduid_loops
= true;
6459 x
= gimple_build_call (builtin_decl_explicit (BUILT_IN_GOMP_ORDERED_START
),
6461 gimple_bind_add_stmt (bind
, x
);
6463 tree counter
= NULL_TREE
, test
= NULL_TREE
, body
= NULL_TREE
;
6466 counter
= create_tmp_var (integer_type_node
);
6467 g
= gimple_build_call_internal (IFN_GOMP_SIMT_LANE
, 0);
6468 gimple_call_set_lhs (g
, counter
);
6469 gimple_bind_add_stmt (bind
, g
);
6471 body
= create_artificial_label (UNKNOWN_LOCATION
);
6472 test
= create_artificial_label (UNKNOWN_LOCATION
);
6473 gimple_bind_add_stmt (bind
, gimple_build_label (body
));
6475 tree simt_pred
= create_tmp_var (integer_type_node
);
6476 g
= gimple_build_call_internal (IFN_GOMP_SIMT_ORDERED_PRED
, 1, counter
);
6477 gimple_call_set_lhs (g
, simt_pred
);
6478 gimple_bind_add_stmt (bind
, g
);
6480 tree t
= create_artificial_label (UNKNOWN_LOCATION
);
6481 g
= gimple_build_cond (EQ_EXPR
, simt_pred
, integer_zero_node
, t
, test
);
6482 gimple_bind_add_stmt (bind
, g
);
6484 gimple_bind_add_stmt (bind
, gimple_build_label (t
));
6486 lower_omp (gimple_omp_body_ptr (stmt
), ctx
);
6487 gimple_omp_set_body (stmt
, maybe_catch_exception (gimple_omp_body (stmt
)));
6488 gimple_bind_add_seq (bind
, gimple_omp_body (stmt
));
6489 gimple_omp_set_body (stmt
, NULL
);
6493 gimple_bind_add_stmt (bind
, gimple_build_label (test
));
6494 g
= gimple_build_assign (counter
, MINUS_EXPR
, counter
, integer_one_node
);
6495 gimple_bind_add_stmt (bind
, g
);
6497 tree c
= build2 (GE_EXPR
, boolean_type_node
, counter
, integer_zero_node
);
6498 tree nonneg
= create_tmp_var (integer_type_node
);
6499 gimple_seq tseq
= NULL
;
6500 gimplify_assign (nonneg
, fold_convert (integer_type_node
, c
), &tseq
);
6501 gimple_bind_add_seq (bind
, tseq
);
6503 g
= gimple_build_call_internal (IFN_GOMP_SIMT_VOTE_ANY
, 1, nonneg
);
6504 gimple_call_set_lhs (g
, nonneg
);
6505 gimple_bind_add_stmt (bind
, g
);
6507 tree end
= create_artificial_label (UNKNOWN_LOCATION
);
6508 g
= gimple_build_cond (NE_EXPR
, nonneg
, integer_zero_node
, body
, end
);
6509 gimple_bind_add_stmt (bind
, g
);
6511 gimple_bind_add_stmt (bind
, gimple_build_label (end
));
6514 x
= gimple_build_call_internal (IFN_GOMP_SIMD_ORDERED_END
, 1,
6515 build_int_cst (NULL_TREE
, threads
));
6517 x
= gimple_build_call (builtin_decl_explicit (BUILT_IN_GOMP_ORDERED_END
),
6519 gimple_bind_add_stmt (bind
, x
);
6521 gimple_bind_add_stmt (bind
, gimple_build_omp_return (true));
6523 pop_gimplify_context (bind
);
6525 gimple_bind_append_vars (bind
, ctx
->block_vars
);
6526 BLOCK_VARS (block
) = gimple_bind_vars (bind
);
6530 /* Gimplify a GIMPLE_OMP_CRITICAL statement. This is a relatively simple
6531 substitution of a couple of function calls. But in the NAMED case,
6532 requires that languages coordinate a symbol name. It is therefore
6533 best put here in common code. */
6535 static GTY(()) hash_map
<tree
, tree
> *critical_name_mutexes
;
6538 lower_omp_critical (gimple_stmt_iterator
*gsi_p
, omp_context
*ctx
)
6541 tree name
, lock
, unlock
;
6542 gomp_critical
*stmt
= as_a
<gomp_critical
*> (gsi_stmt (*gsi_p
));
6544 location_t loc
= gimple_location (stmt
);
6547 name
= gimple_omp_critical_name (stmt
);
6552 if (!critical_name_mutexes
)
6553 critical_name_mutexes
= hash_map
<tree
, tree
>::create_ggc (10);
6555 tree
*n
= critical_name_mutexes
->get (name
);
6560 decl
= create_tmp_var_raw (ptr_type_node
);
6562 new_str
= ACONCAT ((".gomp_critical_user_",
6563 IDENTIFIER_POINTER (name
), NULL
));
6564 DECL_NAME (decl
) = get_identifier (new_str
);
6565 TREE_PUBLIC (decl
) = 1;
6566 TREE_STATIC (decl
) = 1;
6567 DECL_COMMON (decl
) = 1;
6568 DECL_ARTIFICIAL (decl
) = 1;
6569 DECL_IGNORED_P (decl
) = 1;
6571 varpool_node::finalize_decl (decl
);
6573 critical_name_mutexes
->put (name
, decl
);
6578 /* If '#pragma omp critical' is inside offloaded region or
6579 inside function marked as offloadable, the symbol must be
6580 marked as offloadable too. */
6582 if (cgraph_node::get (current_function_decl
)->offloadable
)
6583 varpool_node::get_create (decl
)->offloadable
= 1;
6585 for (octx
= ctx
->outer
; octx
; octx
= octx
->outer
)
6586 if (is_gimple_omp_offloaded (octx
->stmt
))
6588 varpool_node::get_create (decl
)->offloadable
= 1;
6592 lock
= builtin_decl_explicit (BUILT_IN_GOMP_CRITICAL_NAME_START
);
6593 lock
= build_call_expr_loc (loc
, lock
, 1,
6594 build_fold_addr_expr_loc (loc
, decl
));
6596 unlock
= builtin_decl_explicit (BUILT_IN_GOMP_CRITICAL_NAME_END
);
6597 unlock
= build_call_expr_loc (loc
, unlock
, 1,
6598 build_fold_addr_expr_loc (loc
, decl
));
6602 lock
= builtin_decl_explicit (BUILT_IN_GOMP_CRITICAL_START
);
6603 lock
= build_call_expr_loc (loc
, lock
, 0);
6605 unlock
= builtin_decl_explicit (BUILT_IN_GOMP_CRITICAL_END
);
6606 unlock
= build_call_expr_loc (loc
, unlock
, 0);
6609 push_gimplify_context ();
6611 block
= make_node (BLOCK
);
6612 bind
= gimple_build_bind (NULL
, NULL
, block
);
6613 gsi_replace (gsi_p
, bind
, true);
6614 gimple_bind_add_stmt (bind
, stmt
);
6616 tbody
= gimple_bind_body (bind
);
6617 gimplify_and_add (lock
, &tbody
);
6618 gimple_bind_set_body (bind
, tbody
);
6620 lower_omp (gimple_omp_body_ptr (stmt
), ctx
);
6621 gimple_omp_set_body (stmt
, maybe_catch_exception (gimple_omp_body (stmt
)));
6622 gimple_bind_add_seq (bind
, gimple_omp_body (stmt
));
6623 gimple_omp_set_body (stmt
, NULL
);
6625 tbody
= gimple_bind_body (bind
);
6626 gimplify_and_add (unlock
, &tbody
);
6627 gimple_bind_set_body (bind
, tbody
);
6629 gimple_bind_add_stmt (bind
, gimple_build_omp_return (true));
6631 pop_gimplify_context (bind
);
6632 gimple_bind_append_vars (bind
, ctx
->block_vars
);
6633 BLOCK_VARS (block
) = gimple_bind_vars (bind
);
6636 /* A subroutine of lower_omp_for. Generate code to emit the predicate
6637 for a lastprivate clause. Given a loop control predicate of (V
6638 cond N2), we gate the clause on (!(V cond N2)). The lowered form
6639 is appended to *DLIST, iterator initialization is appended to
6643 lower_omp_for_lastprivate (struct omp_for_data
*fd
, gimple_seq
*body_p
,
6644 gimple_seq
*dlist
, struct omp_context
*ctx
)
6646 tree clauses
, cond
, vinit
;
6647 enum tree_code cond_code
;
6650 cond_code
= fd
->loop
.cond_code
;
6651 cond_code
= cond_code
== LT_EXPR
? GE_EXPR
: LE_EXPR
;
6653 /* When possible, use a strict equality expression. This can let VRP
6654 type optimizations deduce the value and remove a copy. */
6655 if (tree_fits_shwi_p (fd
->loop
.step
))
6657 HOST_WIDE_INT step
= tree_to_shwi (fd
->loop
.step
);
6658 if (step
== 1 || step
== -1)
6659 cond_code
= EQ_EXPR
;
6662 if (gimple_omp_for_kind (fd
->for_stmt
) == GF_OMP_FOR_KIND_GRID_LOOP
6663 || gimple_omp_for_grid_phony (fd
->for_stmt
))
6664 cond
= omp_grid_lastprivate_predicate (fd
);
6667 tree n2
= fd
->loop
.n2
;
6668 if (fd
->collapse
> 1
6669 && TREE_CODE (n2
) != INTEGER_CST
6670 && gimple_omp_for_combined_into_p (fd
->for_stmt
))
6672 struct omp_context
*taskreg_ctx
= NULL
;
6673 if (gimple_code (ctx
->outer
->stmt
) == GIMPLE_OMP_FOR
)
6675 gomp_for
*gfor
= as_a
<gomp_for
*> (ctx
->outer
->stmt
);
6676 if (gimple_omp_for_kind (gfor
) == GF_OMP_FOR_KIND_FOR
6677 || gimple_omp_for_kind (gfor
) == GF_OMP_FOR_KIND_DISTRIBUTE
)
6679 if (gimple_omp_for_combined_into_p (gfor
))
6681 gcc_assert (ctx
->outer
->outer
6682 && is_parallel_ctx (ctx
->outer
->outer
));
6683 taskreg_ctx
= ctx
->outer
->outer
;
6687 struct omp_for_data outer_fd
;
6688 omp_extract_for_data (gfor
, &outer_fd
, NULL
);
6689 n2
= fold_convert (TREE_TYPE (n2
), outer_fd
.loop
.n2
);
6692 else if (gimple_omp_for_kind (gfor
) == GF_OMP_FOR_KIND_TASKLOOP
)
6693 taskreg_ctx
= ctx
->outer
->outer
;
6695 else if (is_taskreg_ctx (ctx
->outer
))
6696 taskreg_ctx
= ctx
->outer
;
6700 tree taskreg_clauses
6701 = gimple_omp_taskreg_clauses (taskreg_ctx
->stmt
);
6702 tree innerc
= omp_find_clause (taskreg_clauses
,
6703 OMP_CLAUSE__LOOPTEMP_
);
6704 gcc_assert (innerc
);
6705 for (i
= 0; i
< fd
->collapse
; i
++)
6707 innerc
= omp_find_clause (OMP_CLAUSE_CHAIN (innerc
),
6708 OMP_CLAUSE__LOOPTEMP_
);
6709 gcc_assert (innerc
);
6711 innerc
= omp_find_clause (OMP_CLAUSE_CHAIN (innerc
),
6712 OMP_CLAUSE__LOOPTEMP_
);
6714 n2
= fold_convert (TREE_TYPE (n2
),
6715 lookup_decl (OMP_CLAUSE_DECL (innerc
),
6719 cond
= build2 (cond_code
, boolean_type_node
, fd
->loop
.v
, n2
);
6722 clauses
= gimple_omp_for_clauses (fd
->for_stmt
);
6724 lower_lastprivate_clauses (clauses
, cond
, &stmts
, ctx
);
6725 if (!gimple_seq_empty_p (stmts
))
6727 gimple_seq_add_seq (&stmts
, *dlist
);
6730 /* Optimize: v = 0; is usually cheaper than v = some_other_constant. */
6731 vinit
= fd
->loop
.n1
;
6732 if (cond_code
== EQ_EXPR
6733 && tree_fits_shwi_p (fd
->loop
.n2
)
6734 && ! integer_zerop (fd
->loop
.n2
))
6735 vinit
= build_int_cst (TREE_TYPE (fd
->loop
.v
), 0);
6737 vinit
= unshare_expr (vinit
);
6739 /* Initialize the iterator variable, so that threads that don't execute
6740 any iterations don't execute the lastprivate clauses by accident. */
6741 gimplify_assign (fd
->loop
.v
, vinit
, body_p
);
6746 /* Lower code for an OMP loop directive. */
6749 lower_omp_for (gimple_stmt_iterator
*gsi_p
, omp_context
*ctx
)
6752 struct omp_for_data fd
, *fdp
= NULL
;
6753 gomp_for
*stmt
= as_a
<gomp_for
*> (gsi_stmt (*gsi_p
));
6755 gimple_seq omp_for_body
, body
, dlist
;
6756 gimple_seq oacc_head
= NULL
, oacc_tail
= NULL
;
6759 push_gimplify_context ();
6761 lower_omp (gimple_omp_for_pre_body_ptr (stmt
), ctx
);
6763 block
= make_node (BLOCK
);
6764 new_stmt
= gimple_build_bind (NULL
, NULL
, block
);
6765 /* Replace at gsi right away, so that 'stmt' is no member
6766 of a sequence anymore as we're going to add to a different
6768 gsi_replace (gsi_p
, new_stmt
, true);
6770 /* Move declaration of temporaries in the loop body before we make
6772 omp_for_body
= gimple_omp_body (stmt
);
6773 if (!gimple_seq_empty_p (omp_for_body
)
6774 && gimple_code (gimple_seq_first_stmt (omp_for_body
)) == GIMPLE_BIND
)
6777 = as_a
<gbind
*> (gimple_seq_first_stmt (omp_for_body
));
6778 tree vars
= gimple_bind_vars (inner_bind
);
6779 gimple_bind_append_vars (new_stmt
, vars
);
6780 /* bind_vars/BLOCK_VARS are being moved to new_stmt/block, don't
6781 keep them on the inner_bind and it's block. */
6782 gimple_bind_set_vars (inner_bind
, NULL_TREE
);
6783 if (gimple_bind_block (inner_bind
))
6784 BLOCK_VARS (gimple_bind_block (inner_bind
)) = NULL_TREE
;
6787 if (gimple_omp_for_combined_into_p (stmt
))
6789 omp_extract_for_data (stmt
, &fd
, NULL
);
6792 /* We need two temporaries with fd.loop.v type (istart/iend)
6793 and then (fd.collapse - 1) temporaries with the same
6794 type for count2 ... countN-1 vars if not constant. */
6796 tree type
= fd
.iter_type
;
6798 && TREE_CODE (fd
.loop
.n2
) != INTEGER_CST
)
6799 count
+= fd
.collapse
- 1;
6801 = (gimple_omp_for_kind (stmt
) == GF_OMP_FOR_KIND_FOR
6802 || gimple_omp_for_kind (stmt
) == GF_OMP_FOR_KIND_TASKLOOP
);
6803 tree outerc
= NULL
, *pc
= gimple_omp_for_clauses_ptr (stmt
);
6808 = omp_find_clause (gimple_omp_taskreg_clauses (ctx
->outer
->stmt
),
6809 OMP_CLAUSE__LOOPTEMP_
);
6811 simtc
= omp_find_clause (gimple_omp_for_clauses (ctx
->simt_stmt
),
6812 OMP_CLAUSE__LOOPTEMP_
);
6813 for (i
= 0; i
< count
; i
++)
6818 gcc_assert (outerc
);
6819 temp
= lookup_decl (OMP_CLAUSE_DECL (outerc
), ctx
->outer
);
6820 outerc
= omp_find_clause (OMP_CLAUSE_CHAIN (outerc
),
6821 OMP_CLAUSE__LOOPTEMP_
);
6825 /* If there are 2 adjacent SIMD stmts, one with _simt_
6826 clause, another without, make sure they have the same
6827 decls in _looptemp_ clauses, because the outer stmt
6828 they are combined into will look up just one inner_stmt. */
6830 temp
= OMP_CLAUSE_DECL (simtc
);
6832 temp
= create_tmp_var (type
);
6833 insert_decl_map (&ctx
->outer
->cb
, temp
, temp
);
6835 *pc
= build_omp_clause (UNKNOWN_LOCATION
, OMP_CLAUSE__LOOPTEMP_
);
6836 OMP_CLAUSE_DECL (*pc
) = temp
;
6837 pc
= &OMP_CLAUSE_CHAIN (*pc
);
6839 simtc
= omp_find_clause (OMP_CLAUSE_CHAIN (simtc
),
6840 OMP_CLAUSE__LOOPTEMP_
);
6845 /* The pre-body and input clauses go before the lowered GIMPLE_OMP_FOR. */
6848 lower_rec_input_clauses (gimple_omp_for_clauses (stmt
), &body
, &dlist
, ctx
,
6850 gimple_seq_add_seq (&body
, gimple_omp_for_pre_body (stmt
));
6852 lower_omp (gimple_omp_body_ptr (stmt
), ctx
);
6854 /* Lower the header expressions. At this point, we can assume that
6855 the header is of the form:
6857 #pragma omp for (V = VAL1; V {<|>|<=|>=} VAL2; V = V [+-] VAL3)
6859 We just need to make sure that VAL1, VAL2 and VAL3 are lowered
6860 using the .omp_data_s mapping, if needed. */
6861 for (i
= 0; i
< gimple_omp_for_collapse (stmt
); i
++)
6863 rhs_p
= gimple_omp_for_initial_ptr (stmt
, i
);
6864 if (!is_gimple_min_invariant (*rhs_p
))
6865 *rhs_p
= get_formal_tmp_var (*rhs_p
, &body
);
6866 else if (TREE_CODE (*rhs_p
) == ADDR_EXPR
)
6867 recompute_tree_invariant_for_addr_expr (*rhs_p
);
6869 rhs_p
= gimple_omp_for_final_ptr (stmt
, i
);
6870 if (!is_gimple_min_invariant (*rhs_p
))
6871 *rhs_p
= get_formal_tmp_var (*rhs_p
, &body
);
6872 else if (TREE_CODE (*rhs_p
) == ADDR_EXPR
)
6873 recompute_tree_invariant_for_addr_expr (*rhs_p
);
6875 rhs_p
= &TREE_OPERAND (gimple_omp_for_incr (stmt
, i
), 1);
6876 if (!is_gimple_min_invariant (*rhs_p
))
6877 *rhs_p
= get_formal_tmp_var (*rhs_p
, &body
);
6880 /* Once lowered, extract the bounds and clauses. */
6881 omp_extract_for_data (stmt
, &fd
, NULL
);
6883 if (is_gimple_omp_oacc (ctx
->stmt
)
6884 && !ctx_in_oacc_kernels_region (ctx
))
6885 lower_oacc_head_tail (gimple_location (stmt
),
6886 gimple_omp_for_clauses (stmt
),
6887 &oacc_head
, &oacc_tail
, ctx
);
6889 /* Add OpenACC partitioning and reduction markers just before the loop. */
6891 gimple_seq_add_seq (&body
, oacc_head
);
6893 lower_omp_for_lastprivate (&fd
, &body
, &dlist
, ctx
);
6895 if (gimple_omp_for_kind (stmt
) == GF_OMP_FOR_KIND_FOR
)
6896 for (tree c
= gimple_omp_for_clauses (stmt
); c
; c
= OMP_CLAUSE_CHAIN (c
))
6897 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_LINEAR
6898 && !OMP_CLAUSE_LINEAR_NO_COPYIN (c
))
6900 OMP_CLAUSE_DECL (c
) = lookup_decl (OMP_CLAUSE_DECL (c
), ctx
);
6901 if (DECL_P (OMP_CLAUSE_LINEAR_STEP (c
)))
6902 OMP_CLAUSE_LINEAR_STEP (c
)
6903 = maybe_lookup_decl_in_outer_ctx (OMP_CLAUSE_LINEAR_STEP (c
),
6907 bool phony_loop
= (gimple_omp_for_kind (stmt
) != GF_OMP_FOR_KIND_GRID_LOOP
6908 && gimple_omp_for_grid_phony (stmt
));
6910 gimple_seq_add_stmt (&body
, stmt
);
6911 gimple_seq_add_seq (&body
, gimple_omp_body (stmt
));
6914 gimple_seq_add_stmt (&body
, gimple_build_omp_continue (fd
.loop
.v
,
6917 /* After the loop, add exit clauses. */
6918 lower_reduction_clauses (gimple_omp_for_clauses (stmt
), &body
, ctx
);
6920 if (ctx
->cancellable
)
6921 gimple_seq_add_stmt (&body
, gimple_build_label (ctx
->cancel_label
));
6923 gimple_seq_add_seq (&body
, dlist
);
6925 body
= maybe_catch_exception (body
);
6929 /* Region exit marker goes at the end of the loop body. */
6930 gimple_seq_add_stmt (&body
, gimple_build_omp_return (fd
.have_nowait
));
6931 maybe_add_implicit_barrier_cancel (ctx
, &body
);
6934 /* Add OpenACC joining and reduction markers just after the loop. */
6936 gimple_seq_add_seq (&body
, oacc_tail
);
6938 pop_gimplify_context (new_stmt
);
6940 gimple_bind_append_vars (new_stmt
, ctx
->block_vars
);
6941 maybe_remove_omp_member_access_dummy_vars (new_stmt
);
6942 BLOCK_VARS (block
) = gimple_bind_vars (new_stmt
);
6943 if (BLOCK_VARS (block
))
6944 TREE_USED (block
) = 1;
6946 gimple_bind_set_body (new_stmt
, body
);
6947 gimple_omp_set_body (stmt
, NULL
);
6948 gimple_omp_for_set_pre_body (stmt
, NULL
);
6951 /* Callback for walk_stmts. Check if the current statement only contains
6952 GIMPLE_OMP_FOR or GIMPLE_OMP_SECTIONS. */
6955 check_combined_parallel (gimple_stmt_iterator
*gsi_p
,
6956 bool *handled_ops_p
,
6957 struct walk_stmt_info
*wi
)
6959 int *info
= (int *) wi
->info
;
6960 gimple
*stmt
= gsi_stmt (*gsi_p
);
6962 *handled_ops_p
= true;
6963 switch (gimple_code (stmt
))
6969 case GIMPLE_OMP_FOR
:
6970 case GIMPLE_OMP_SECTIONS
:
6971 *info
= *info
== 0 ? 1 : -1;
6980 struct omp_taskcopy_context
6982 /* This field must be at the beginning, as we do "inheritance": Some
6983 callback functions for tree-inline.c (e.g., omp_copy_decl)
6984 receive a copy_body_data pointer that is up-casted to an
6985 omp_context pointer. */
6991 task_copyfn_copy_decl (tree var
, copy_body_data
*cb
)
6993 struct omp_taskcopy_context
*tcctx
= (struct omp_taskcopy_context
*) cb
;
6995 if (splay_tree_lookup (tcctx
->ctx
->sfield_map
, (splay_tree_key
) var
))
6996 return create_tmp_var (TREE_TYPE (var
));
7002 task_copyfn_remap_type (struct omp_taskcopy_context
*tcctx
, tree orig_type
)
7004 tree name
, new_fields
= NULL
, type
, f
;
7006 type
= lang_hooks
.types
.make_type (RECORD_TYPE
);
7007 name
= DECL_NAME (TYPE_NAME (orig_type
));
7008 name
= build_decl (gimple_location (tcctx
->ctx
->stmt
),
7009 TYPE_DECL
, name
, type
);
7010 TYPE_NAME (type
) = name
;
7012 for (f
= TYPE_FIELDS (orig_type
); f
; f
= TREE_CHAIN (f
))
7014 tree new_f
= copy_node (f
);
7015 DECL_CONTEXT (new_f
) = type
;
7016 TREE_TYPE (new_f
) = remap_type (TREE_TYPE (f
), &tcctx
->cb
);
7017 TREE_CHAIN (new_f
) = new_fields
;
7018 walk_tree (&DECL_SIZE (new_f
), copy_tree_body_r
, &tcctx
->cb
, NULL
);
7019 walk_tree (&DECL_SIZE_UNIT (new_f
), copy_tree_body_r
, &tcctx
->cb
, NULL
);
7020 walk_tree (&DECL_FIELD_OFFSET (new_f
), copy_tree_body_r
,
7023 tcctx
->cb
.decl_map
->put (f
, new_f
);
7025 TYPE_FIELDS (type
) = nreverse (new_fields
);
7030 /* Create task copyfn. */
7033 create_task_copyfn (gomp_task
*task_stmt
, omp_context
*ctx
)
7035 struct function
*child_cfun
;
7036 tree child_fn
, t
, c
, src
, dst
, f
, sf
, arg
, sarg
, decl
;
7037 tree record_type
, srecord_type
, bind
, list
;
7038 bool record_needs_remap
= false, srecord_needs_remap
= false;
7040 struct omp_taskcopy_context tcctx
;
7041 location_t loc
= gimple_location (task_stmt
);
7042 size_t looptempno
= 0;
7044 child_fn
= gimple_omp_task_copy_fn (task_stmt
);
7045 child_cfun
= DECL_STRUCT_FUNCTION (child_fn
);
7046 gcc_assert (child_cfun
->cfg
== NULL
);
7047 DECL_SAVED_TREE (child_fn
) = alloc_stmt_list ();
7049 /* Reset DECL_CONTEXT on function arguments. */
7050 for (t
= DECL_ARGUMENTS (child_fn
); t
; t
= DECL_CHAIN (t
))
7051 DECL_CONTEXT (t
) = child_fn
;
7053 /* Populate the function. */
7054 push_gimplify_context ();
7055 push_cfun (child_cfun
);
7057 bind
= build3 (BIND_EXPR
, void_type_node
, NULL
, NULL
, NULL
);
7058 TREE_SIDE_EFFECTS (bind
) = 1;
7060 DECL_SAVED_TREE (child_fn
) = bind
;
7061 DECL_SOURCE_LOCATION (child_fn
) = gimple_location (task_stmt
);
7063 /* Remap src and dst argument types if needed. */
7064 record_type
= ctx
->record_type
;
7065 srecord_type
= ctx
->srecord_type
;
7066 for (f
= TYPE_FIELDS (record_type
); f
; f
= DECL_CHAIN (f
))
7067 if (variably_modified_type_p (TREE_TYPE (f
), ctx
->cb
.src_fn
))
7069 record_needs_remap
= true;
7072 for (f
= TYPE_FIELDS (srecord_type
); f
; f
= DECL_CHAIN (f
))
7073 if (variably_modified_type_p (TREE_TYPE (f
), ctx
->cb
.src_fn
))
7075 srecord_needs_remap
= true;
7079 if (record_needs_remap
|| srecord_needs_remap
)
7081 memset (&tcctx
, '\0', sizeof (tcctx
));
7082 tcctx
.cb
.src_fn
= ctx
->cb
.src_fn
;
7083 tcctx
.cb
.dst_fn
= child_fn
;
7084 tcctx
.cb
.src_node
= cgraph_node::get (tcctx
.cb
.src_fn
);
7085 gcc_checking_assert (tcctx
.cb
.src_node
);
7086 tcctx
.cb
.dst_node
= tcctx
.cb
.src_node
;
7087 tcctx
.cb
.src_cfun
= ctx
->cb
.src_cfun
;
7088 tcctx
.cb
.copy_decl
= task_copyfn_copy_decl
;
7089 tcctx
.cb
.eh_lp_nr
= 0;
7090 tcctx
.cb
.transform_call_graph_edges
= CB_CGE_MOVE
;
7091 tcctx
.cb
.decl_map
= new hash_map
<tree
, tree
>;
7094 if (record_needs_remap
)
7095 record_type
= task_copyfn_remap_type (&tcctx
, record_type
);
7096 if (srecord_needs_remap
)
7097 srecord_type
= task_copyfn_remap_type (&tcctx
, srecord_type
);
7100 tcctx
.cb
.decl_map
= NULL
;
7102 arg
= DECL_ARGUMENTS (child_fn
);
7103 TREE_TYPE (arg
) = build_pointer_type (record_type
);
7104 sarg
= DECL_CHAIN (arg
);
7105 TREE_TYPE (sarg
) = build_pointer_type (srecord_type
);
7107 /* First pass: initialize temporaries used in record_type and srecord_type
7108 sizes and field offsets. */
7109 if (tcctx
.cb
.decl_map
)
7110 for (c
= gimple_omp_task_clauses (task_stmt
); c
; c
= OMP_CLAUSE_CHAIN (c
))
7111 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_FIRSTPRIVATE
)
7115 decl
= OMP_CLAUSE_DECL (c
);
7116 p
= tcctx
.cb
.decl_map
->get (decl
);
7119 n
= splay_tree_lookup (ctx
->sfield_map
, (splay_tree_key
) decl
);
7120 sf
= (tree
) n
->value
;
7121 sf
= *tcctx
.cb
.decl_map
->get (sf
);
7122 src
= build_simple_mem_ref_loc (loc
, sarg
);
7123 src
= omp_build_component_ref (src
, sf
);
7124 t
= build2 (MODIFY_EXPR
, TREE_TYPE (*p
), *p
, src
);
7125 append_to_statement_list (t
, &list
);
7128 /* Second pass: copy shared var pointers and copy construct non-VLA
7129 firstprivate vars. */
7130 for (c
= gimple_omp_task_clauses (task_stmt
); c
; c
= OMP_CLAUSE_CHAIN (c
))
7131 switch (OMP_CLAUSE_CODE (c
))
7134 case OMP_CLAUSE_SHARED
:
7135 decl
= OMP_CLAUSE_DECL (c
);
7136 key
= (splay_tree_key
) decl
;
7137 if (OMP_CLAUSE_SHARED_FIRSTPRIVATE (c
))
7138 key
= (splay_tree_key
) &DECL_UID (decl
);
7139 n
= splay_tree_lookup (ctx
->field_map
, key
);
7142 f
= (tree
) n
->value
;
7143 if (tcctx
.cb
.decl_map
)
7144 f
= *tcctx
.cb
.decl_map
->get (f
);
7145 n
= splay_tree_lookup (ctx
->sfield_map
, key
);
7146 sf
= (tree
) n
->value
;
7147 if (tcctx
.cb
.decl_map
)
7148 sf
= *tcctx
.cb
.decl_map
->get (sf
);
7149 src
= build_simple_mem_ref_loc (loc
, sarg
);
7150 src
= omp_build_component_ref (src
, sf
);
7151 dst
= build_simple_mem_ref_loc (loc
, arg
);
7152 dst
= omp_build_component_ref (dst
, f
);
7153 t
= build2 (MODIFY_EXPR
, TREE_TYPE (dst
), dst
, src
);
7154 append_to_statement_list (t
, &list
);
7156 case OMP_CLAUSE__LOOPTEMP_
:
7157 /* Fields for first two _looptemp_ clauses are initialized by
7158 GOMP_taskloop*, the rest are handled like firstprivate. */
7165 case OMP_CLAUSE_FIRSTPRIVATE
:
7166 decl
= OMP_CLAUSE_DECL (c
);
7167 if (is_variable_sized (decl
))
7169 n
= splay_tree_lookup (ctx
->field_map
, (splay_tree_key
) decl
);
7172 f
= (tree
) n
->value
;
7173 if (tcctx
.cb
.decl_map
)
7174 f
= *tcctx
.cb
.decl_map
->get (f
);
7175 n
= splay_tree_lookup (ctx
->sfield_map
, (splay_tree_key
) decl
);
7178 sf
= (tree
) n
->value
;
7179 if (tcctx
.cb
.decl_map
)
7180 sf
= *tcctx
.cb
.decl_map
->get (sf
);
7181 src
= build_simple_mem_ref_loc (loc
, sarg
);
7182 src
= omp_build_component_ref (src
, sf
);
7183 if (use_pointer_for_field (decl
, NULL
) || omp_is_reference (decl
))
7184 src
= build_simple_mem_ref_loc (loc
, src
);
7188 dst
= build_simple_mem_ref_loc (loc
, arg
);
7189 dst
= omp_build_component_ref (dst
, f
);
7190 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE__LOOPTEMP_
)
7191 t
= build2 (MODIFY_EXPR
, TREE_TYPE (dst
), dst
, src
);
7193 t
= lang_hooks
.decls
.omp_clause_copy_ctor (c
, dst
, src
);
7194 append_to_statement_list (t
, &list
);
7196 case OMP_CLAUSE_PRIVATE
:
7197 if (! OMP_CLAUSE_PRIVATE_OUTER_REF (c
))
7199 decl
= OMP_CLAUSE_DECL (c
);
7200 n
= splay_tree_lookup (ctx
->field_map
, (splay_tree_key
) decl
);
7201 f
= (tree
) n
->value
;
7202 if (tcctx
.cb
.decl_map
)
7203 f
= *tcctx
.cb
.decl_map
->get (f
);
7204 n
= splay_tree_lookup (ctx
->sfield_map
, (splay_tree_key
) decl
);
7207 sf
= (tree
) n
->value
;
7208 if (tcctx
.cb
.decl_map
)
7209 sf
= *tcctx
.cb
.decl_map
->get (sf
);
7210 src
= build_simple_mem_ref_loc (loc
, sarg
);
7211 src
= omp_build_component_ref (src
, sf
);
7212 if (use_pointer_for_field (decl
, NULL
))
7213 src
= build_simple_mem_ref_loc (loc
, src
);
7217 dst
= build_simple_mem_ref_loc (loc
, arg
);
7218 dst
= omp_build_component_ref (dst
, f
);
7219 t
= build2 (MODIFY_EXPR
, TREE_TYPE (dst
), dst
, src
);
7220 append_to_statement_list (t
, &list
);
7226 /* Last pass: handle VLA firstprivates. */
7227 if (tcctx
.cb
.decl_map
)
7228 for (c
= gimple_omp_task_clauses (task_stmt
); c
; c
= OMP_CLAUSE_CHAIN (c
))
7229 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_FIRSTPRIVATE
)
7233 decl
= OMP_CLAUSE_DECL (c
);
7234 if (!is_variable_sized (decl
))
7236 n
= splay_tree_lookup (ctx
->field_map
, (splay_tree_key
) decl
);
7239 f
= (tree
) n
->value
;
7240 f
= *tcctx
.cb
.decl_map
->get (f
);
7241 gcc_assert (DECL_HAS_VALUE_EXPR_P (decl
));
7242 ind
= DECL_VALUE_EXPR (decl
);
7243 gcc_assert (TREE_CODE (ind
) == INDIRECT_REF
);
7244 gcc_assert (DECL_P (TREE_OPERAND (ind
, 0)));
7245 n
= splay_tree_lookup (ctx
->sfield_map
,
7246 (splay_tree_key
) TREE_OPERAND (ind
, 0));
7247 sf
= (tree
) n
->value
;
7248 sf
= *tcctx
.cb
.decl_map
->get (sf
);
7249 src
= build_simple_mem_ref_loc (loc
, sarg
);
7250 src
= omp_build_component_ref (src
, sf
);
7251 src
= build_simple_mem_ref_loc (loc
, src
);
7252 dst
= build_simple_mem_ref_loc (loc
, arg
);
7253 dst
= omp_build_component_ref (dst
, f
);
7254 t
= lang_hooks
.decls
.omp_clause_copy_ctor (c
, dst
, src
);
7255 append_to_statement_list (t
, &list
);
7256 n
= splay_tree_lookup (ctx
->field_map
,
7257 (splay_tree_key
) TREE_OPERAND (ind
, 0));
7258 df
= (tree
) n
->value
;
7259 df
= *tcctx
.cb
.decl_map
->get (df
);
7260 ptr
= build_simple_mem_ref_loc (loc
, arg
);
7261 ptr
= omp_build_component_ref (ptr
, df
);
7262 t
= build2 (MODIFY_EXPR
, TREE_TYPE (ptr
), ptr
,
7263 build_fold_addr_expr_loc (loc
, dst
));
7264 append_to_statement_list (t
, &list
);
7267 t
= build1 (RETURN_EXPR
, void_type_node
, NULL
);
7268 append_to_statement_list (t
, &list
);
7270 if (tcctx
.cb
.decl_map
)
7271 delete tcctx
.cb
.decl_map
;
7272 pop_gimplify_context (NULL
);
7273 BIND_EXPR_BODY (bind
) = list
;
7278 lower_depend_clauses (tree
*pclauses
, gimple_seq
*iseq
, gimple_seq
*oseq
)
7282 size_t n_in
= 0, n_out
= 0, idx
= 2, i
;
7284 clauses
= omp_find_clause (*pclauses
, OMP_CLAUSE_DEPEND
);
7285 gcc_assert (clauses
);
7286 for (c
= clauses
; c
; c
= OMP_CLAUSE_CHAIN (c
))
7287 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_DEPEND
)
7288 switch (OMP_CLAUSE_DEPEND_KIND (c
))
7290 case OMP_CLAUSE_DEPEND_IN
:
7293 case OMP_CLAUSE_DEPEND_OUT
:
7294 case OMP_CLAUSE_DEPEND_INOUT
:
7297 case OMP_CLAUSE_DEPEND_SOURCE
:
7298 case OMP_CLAUSE_DEPEND_SINK
:
7303 tree type
= build_array_type_nelts (ptr_type_node
, n_in
+ n_out
+ 2);
7304 tree array
= create_tmp_var (type
);
7305 TREE_ADDRESSABLE (array
) = 1;
7306 tree r
= build4 (ARRAY_REF
, ptr_type_node
, array
, size_int (0), NULL_TREE
,
7308 g
= gimple_build_assign (r
, build_int_cst (ptr_type_node
, n_in
+ n_out
));
7309 gimple_seq_add_stmt (iseq
, g
);
7310 r
= build4 (ARRAY_REF
, ptr_type_node
, array
, size_int (1), NULL_TREE
,
7312 g
= gimple_build_assign (r
, build_int_cst (ptr_type_node
, n_out
));
7313 gimple_seq_add_stmt (iseq
, g
);
7314 for (i
= 0; i
< 2; i
++)
7316 if ((i
? n_in
: n_out
) == 0)
7318 for (c
= clauses
; c
; c
= OMP_CLAUSE_CHAIN (c
))
7319 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_DEPEND
7320 && ((OMP_CLAUSE_DEPEND_KIND (c
) != OMP_CLAUSE_DEPEND_IN
) ^ i
))
7322 tree t
= OMP_CLAUSE_DECL (c
);
7323 t
= fold_convert (ptr_type_node
, t
);
7324 gimplify_expr (&t
, iseq
, NULL
, is_gimple_val
, fb_rvalue
);
7325 r
= build4 (ARRAY_REF
, ptr_type_node
, array
, size_int (idx
++),
7326 NULL_TREE
, NULL_TREE
);
7327 g
= gimple_build_assign (r
, t
);
7328 gimple_seq_add_stmt (iseq
, g
);
7331 c
= build_omp_clause (UNKNOWN_LOCATION
, OMP_CLAUSE_DEPEND
);
7332 OMP_CLAUSE_DECL (c
) = build_fold_addr_expr (array
);
7333 OMP_CLAUSE_CHAIN (c
) = *pclauses
;
7335 tree clobber
= build_constructor (type
, NULL
);
7336 TREE_THIS_VOLATILE (clobber
) = 1;
7337 g
= gimple_build_assign (array
, clobber
);
7338 gimple_seq_add_stmt (oseq
, g
);
7341 /* Lower the OpenMP parallel or task directive in the current statement
7342 in GSI_P. CTX holds context information for the directive. */
7345 lower_omp_taskreg (gimple_stmt_iterator
*gsi_p
, omp_context
*ctx
)
7349 gimple
*stmt
= gsi_stmt (*gsi_p
);
7350 gbind
*par_bind
, *bind
, *dep_bind
= NULL
;
7351 gimple_seq par_body
, olist
, ilist
, par_olist
, par_rlist
, par_ilist
, new_body
;
7352 location_t loc
= gimple_location (stmt
);
7354 clauses
= gimple_omp_taskreg_clauses (stmt
);
7356 = as_a
<gbind
*> (gimple_seq_first_stmt (gimple_omp_body (stmt
)));
7357 par_body
= gimple_bind_body (par_bind
);
7358 child_fn
= ctx
->cb
.dst_fn
;
7359 if (gimple_code (stmt
) == GIMPLE_OMP_PARALLEL
7360 && !gimple_omp_parallel_combined_p (stmt
))
7362 struct walk_stmt_info wi
;
7365 memset (&wi
, 0, sizeof (wi
));
7368 walk_gimple_seq (par_body
, check_combined_parallel
, NULL
, &wi
);
7370 gimple_omp_parallel_set_combined_p (stmt
, true);
7372 gimple_seq dep_ilist
= NULL
;
7373 gimple_seq dep_olist
= NULL
;
7374 if (gimple_code (stmt
) == GIMPLE_OMP_TASK
7375 && omp_find_clause (clauses
, OMP_CLAUSE_DEPEND
))
7377 push_gimplify_context ();
7378 dep_bind
= gimple_build_bind (NULL
, NULL
, make_node (BLOCK
));
7379 lower_depend_clauses (gimple_omp_task_clauses_ptr (stmt
),
7380 &dep_ilist
, &dep_olist
);
7383 if (ctx
->srecord_type
)
7384 create_task_copyfn (as_a
<gomp_task
*> (stmt
), ctx
);
7386 push_gimplify_context ();
7391 bool phony_construct
= gimple_code (stmt
) == GIMPLE_OMP_PARALLEL
7392 && gimple_omp_parallel_grid_phony (as_a
<gomp_parallel
*> (stmt
));
7393 if (phony_construct
&& ctx
->record_type
)
7395 gcc_checking_assert (!ctx
->receiver_decl
);
7396 ctx
->receiver_decl
= create_tmp_var
7397 (build_reference_type (ctx
->record_type
), ".omp_rec");
7399 lower_rec_input_clauses (clauses
, &par_ilist
, &par_olist
, ctx
, NULL
);
7400 lower_omp (&par_body
, ctx
);
7401 if (gimple_code (stmt
) == GIMPLE_OMP_PARALLEL
)
7402 lower_reduction_clauses (clauses
, &par_rlist
, ctx
);
7404 /* Declare all the variables created by mapping and the variables
7405 declared in the scope of the parallel body. */
7406 record_vars_into (ctx
->block_vars
, child_fn
);
7407 maybe_remove_omp_member_access_dummy_vars (par_bind
);
7408 record_vars_into (gimple_bind_vars (par_bind
), child_fn
);
7410 if (ctx
->record_type
)
7413 = create_tmp_var (ctx
->srecord_type
? ctx
->srecord_type
7414 : ctx
->record_type
, ".omp_data_o");
7415 DECL_NAMELESS (ctx
->sender_decl
) = 1;
7416 TREE_ADDRESSABLE (ctx
->sender_decl
) = 1;
7417 gimple_omp_taskreg_set_data_arg (stmt
, ctx
->sender_decl
);
7422 lower_send_clauses (clauses
, &ilist
, &olist
, ctx
);
7423 lower_send_shared_vars (&ilist
, &olist
, ctx
);
7425 if (ctx
->record_type
)
7427 tree clobber
= build_constructor (TREE_TYPE (ctx
->sender_decl
), NULL
);
7428 TREE_THIS_VOLATILE (clobber
) = 1;
7429 gimple_seq_add_stmt (&olist
, gimple_build_assign (ctx
->sender_decl
,
7433 /* Once all the expansions are done, sequence all the different
7434 fragments inside gimple_omp_body. */
7438 if (ctx
->record_type
)
7440 t
= build_fold_addr_expr_loc (loc
, ctx
->sender_decl
);
7441 /* fixup_child_record_type might have changed receiver_decl's type. */
7442 t
= fold_convert_loc (loc
, TREE_TYPE (ctx
->receiver_decl
), t
);
7443 gimple_seq_add_stmt (&new_body
,
7444 gimple_build_assign (ctx
->receiver_decl
, t
));
7447 gimple_seq_add_seq (&new_body
, par_ilist
);
7448 gimple_seq_add_seq (&new_body
, par_body
);
7449 gimple_seq_add_seq (&new_body
, par_rlist
);
7450 if (ctx
->cancellable
)
7451 gimple_seq_add_stmt (&new_body
, gimple_build_label (ctx
->cancel_label
));
7452 gimple_seq_add_seq (&new_body
, par_olist
);
7453 new_body
= maybe_catch_exception (new_body
);
7454 if (gimple_code (stmt
) == GIMPLE_OMP_TASK
)
7455 gimple_seq_add_stmt (&new_body
,
7456 gimple_build_omp_continue (integer_zero_node
,
7457 integer_zero_node
));
7458 if (!phony_construct
)
7460 gimple_seq_add_stmt (&new_body
, gimple_build_omp_return (false));
7461 gimple_omp_set_body (stmt
, new_body
);
7464 bind
= gimple_build_bind (NULL
, NULL
, gimple_bind_block (par_bind
));
7465 gsi_replace (gsi_p
, dep_bind
? dep_bind
: bind
, true);
7466 gimple_bind_add_seq (bind
, ilist
);
7467 if (!phony_construct
)
7468 gimple_bind_add_stmt (bind
, stmt
);
7470 gimple_bind_add_seq (bind
, new_body
);
7471 gimple_bind_add_seq (bind
, olist
);
7473 pop_gimplify_context (NULL
);
7477 gimple_bind_add_seq (dep_bind
, dep_ilist
);
7478 gimple_bind_add_stmt (dep_bind
, bind
);
7479 gimple_bind_add_seq (dep_bind
, dep_olist
);
7480 pop_gimplify_context (dep_bind
);
7484 /* Lower the GIMPLE_OMP_TARGET in the current statement
7485 in GSI_P. CTX holds context information for the directive. */
7488 lower_omp_target (gimple_stmt_iterator
*gsi_p
, omp_context
*ctx
)
7491 tree child_fn
, t
, c
;
7492 gomp_target
*stmt
= as_a
<gomp_target
*> (gsi_stmt (*gsi_p
));
7493 gbind
*tgt_bind
, *bind
, *dep_bind
= NULL
;
7494 gimple_seq tgt_body
, olist
, ilist
, fplist
, new_body
;
7495 location_t loc
= gimple_location (stmt
);
7496 bool offloaded
, data_region
;
7497 unsigned int map_cnt
= 0;
7499 offloaded
= is_gimple_omp_offloaded (stmt
);
7500 switch (gimple_omp_target_kind (stmt
))
7502 case GF_OMP_TARGET_KIND_REGION
:
7503 case GF_OMP_TARGET_KIND_UPDATE
:
7504 case GF_OMP_TARGET_KIND_ENTER_DATA
:
7505 case GF_OMP_TARGET_KIND_EXIT_DATA
:
7506 case GF_OMP_TARGET_KIND_OACC_PARALLEL
:
7507 case GF_OMP_TARGET_KIND_OACC_KERNELS
:
7508 case GF_OMP_TARGET_KIND_OACC_UPDATE
:
7509 case GF_OMP_TARGET_KIND_OACC_ENTER_EXIT_DATA
:
7510 case GF_OMP_TARGET_KIND_OACC_DECLARE
:
7511 data_region
= false;
7513 case GF_OMP_TARGET_KIND_DATA
:
7514 case GF_OMP_TARGET_KIND_OACC_DATA
:
7515 case GF_OMP_TARGET_KIND_OACC_HOST_DATA
:
7522 clauses
= gimple_omp_target_clauses (stmt
);
7524 gimple_seq dep_ilist
= NULL
;
7525 gimple_seq dep_olist
= NULL
;
7526 if (omp_find_clause (clauses
, OMP_CLAUSE_DEPEND
))
7528 push_gimplify_context ();
7529 dep_bind
= gimple_build_bind (NULL
, NULL
, make_node (BLOCK
));
7530 lower_depend_clauses (gimple_omp_target_clauses_ptr (stmt
),
7531 &dep_ilist
, &dep_olist
);
7538 tgt_bind
= gimple_seq_first_stmt_as_a_bind (gimple_omp_body (stmt
));
7539 tgt_body
= gimple_bind_body (tgt_bind
);
7541 else if (data_region
)
7542 tgt_body
= gimple_omp_body (stmt
);
7543 child_fn
= ctx
->cb
.dst_fn
;
7545 push_gimplify_context ();
7548 for (c
= clauses
; c
; c
= OMP_CLAUSE_CHAIN (c
))
7549 switch (OMP_CLAUSE_CODE (c
))
7555 case OMP_CLAUSE_MAP
:
7557 /* First check what we're prepared to handle in the following. */
7558 switch (OMP_CLAUSE_MAP_KIND (c
))
7560 case GOMP_MAP_ALLOC
:
7563 case GOMP_MAP_TOFROM
:
7564 case GOMP_MAP_POINTER
:
7565 case GOMP_MAP_TO_PSET
:
7566 case GOMP_MAP_DELETE
:
7567 case GOMP_MAP_RELEASE
:
7568 case GOMP_MAP_ALWAYS_TO
:
7569 case GOMP_MAP_ALWAYS_FROM
:
7570 case GOMP_MAP_ALWAYS_TOFROM
:
7571 case GOMP_MAP_FIRSTPRIVATE_POINTER
:
7572 case GOMP_MAP_FIRSTPRIVATE_REFERENCE
:
7573 case GOMP_MAP_STRUCT
:
7574 case GOMP_MAP_ALWAYS_POINTER
:
7576 case GOMP_MAP_FORCE_ALLOC
:
7577 case GOMP_MAP_FORCE_TO
:
7578 case GOMP_MAP_FORCE_FROM
:
7579 case GOMP_MAP_FORCE_TOFROM
:
7580 case GOMP_MAP_FORCE_PRESENT
:
7581 case GOMP_MAP_FORCE_DEVICEPTR
:
7582 case GOMP_MAP_DEVICE_RESIDENT
:
7584 gcc_assert (is_gimple_omp_oacc (stmt
));
7592 case OMP_CLAUSE_FROM
:
7594 var
= OMP_CLAUSE_DECL (c
);
7597 if (OMP_CLAUSE_CODE (c
) != OMP_CLAUSE_MAP
7598 || (!OMP_CLAUSE_MAP_ZERO_BIAS_ARRAY_SECTION (c
)
7599 && (OMP_CLAUSE_MAP_KIND (c
)
7600 != GOMP_MAP_FIRSTPRIVATE_POINTER
)))
7606 && TREE_CODE (DECL_SIZE (var
)) != INTEGER_CST
)
7608 tree var2
= DECL_VALUE_EXPR (var
);
7609 gcc_assert (TREE_CODE (var2
) == INDIRECT_REF
);
7610 var2
= TREE_OPERAND (var2
, 0);
7611 gcc_assert (DECL_P (var2
));
7616 && OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_MAP
7617 && (OMP_CLAUSE_MAP_KIND (c
) == GOMP_MAP_FIRSTPRIVATE_POINTER
7618 || OMP_CLAUSE_MAP_KIND (c
) == GOMP_MAP_FIRSTPRIVATE_REFERENCE
))
7620 if (TREE_CODE (TREE_TYPE (var
)) == ARRAY_TYPE
)
7622 if (is_global_var (maybe_lookup_decl_in_outer_ctx (var
, ctx
))
7623 && varpool_node::get_create (var
)->offloadable
)
7626 tree type
= build_pointer_type (TREE_TYPE (var
));
7627 tree new_var
= lookup_decl (var
, ctx
);
7628 x
= create_tmp_var_raw (type
, get_name (new_var
));
7629 gimple_add_tmp_var (x
);
7630 x
= build_simple_mem_ref (x
);
7631 SET_DECL_VALUE_EXPR (new_var
, x
);
7632 DECL_HAS_VALUE_EXPR_P (new_var
) = 1;
7637 if (!maybe_lookup_field (var
, ctx
))
7640 /* Don't remap oacc parallel reduction variables, because the
7641 intermediate result must be local to each gang. */
7642 if (offloaded
&& !(OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_MAP
7643 && OMP_CLAUSE_MAP_IN_REDUCTION (c
)))
7645 x
= build_receiver_ref (var
, true, ctx
);
7646 tree new_var
= lookup_decl (var
, ctx
);
7648 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_MAP
7649 && OMP_CLAUSE_MAP_KIND (c
) == GOMP_MAP_POINTER
7650 && !OMP_CLAUSE_MAP_ZERO_BIAS_ARRAY_SECTION (c
)
7651 && TREE_CODE (TREE_TYPE (var
)) == ARRAY_TYPE
)
7652 x
= build_simple_mem_ref (x
);
7653 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_FIRSTPRIVATE
)
7655 gcc_assert (is_gimple_omp_oacc (ctx
->stmt
));
7656 if (omp_is_reference (new_var
)
7657 && TREE_CODE (TREE_TYPE (new_var
)) != POINTER_TYPE
)
7659 /* Create a local object to hold the instance
7661 tree type
= TREE_TYPE (TREE_TYPE (new_var
));
7662 const char *id
= IDENTIFIER_POINTER (DECL_NAME (new_var
));
7663 tree inst
= create_tmp_var (type
, id
);
7664 gimplify_assign (inst
, fold_indirect_ref (x
), &fplist
);
7665 x
= build_fold_addr_expr (inst
);
7667 gimplify_assign (new_var
, x
, &fplist
);
7669 else if (DECL_P (new_var
))
7671 SET_DECL_VALUE_EXPR (new_var
, x
);
7672 DECL_HAS_VALUE_EXPR_P (new_var
) = 1;
7680 case OMP_CLAUSE_FIRSTPRIVATE
:
7681 if (is_oacc_parallel (ctx
))
7682 goto oacc_firstprivate
;
7684 var
= OMP_CLAUSE_DECL (c
);
7685 if (!omp_is_reference (var
)
7686 && !is_gimple_reg_type (TREE_TYPE (var
)))
7688 tree new_var
= lookup_decl (var
, ctx
);
7689 if (is_variable_sized (var
))
7691 tree pvar
= DECL_VALUE_EXPR (var
);
7692 gcc_assert (TREE_CODE (pvar
) == INDIRECT_REF
);
7693 pvar
= TREE_OPERAND (pvar
, 0);
7694 gcc_assert (DECL_P (pvar
));
7695 tree new_pvar
= lookup_decl (pvar
, ctx
);
7696 x
= build_fold_indirect_ref (new_pvar
);
7697 TREE_THIS_NOTRAP (x
) = 1;
7700 x
= build_receiver_ref (var
, true, ctx
);
7701 SET_DECL_VALUE_EXPR (new_var
, x
);
7702 DECL_HAS_VALUE_EXPR_P (new_var
) = 1;
7706 case OMP_CLAUSE_PRIVATE
:
7707 if (is_gimple_omp_oacc (ctx
->stmt
))
7709 var
= OMP_CLAUSE_DECL (c
);
7710 if (is_variable_sized (var
))
7712 tree new_var
= lookup_decl (var
, ctx
);
7713 tree pvar
= DECL_VALUE_EXPR (var
);
7714 gcc_assert (TREE_CODE (pvar
) == INDIRECT_REF
);
7715 pvar
= TREE_OPERAND (pvar
, 0);
7716 gcc_assert (DECL_P (pvar
));
7717 tree new_pvar
= lookup_decl (pvar
, ctx
);
7718 x
= build_fold_indirect_ref (new_pvar
);
7719 TREE_THIS_NOTRAP (x
) = 1;
7720 SET_DECL_VALUE_EXPR (new_var
, x
);
7721 DECL_HAS_VALUE_EXPR_P (new_var
) = 1;
7725 case OMP_CLAUSE_USE_DEVICE_PTR
:
7726 case OMP_CLAUSE_IS_DEVICE_PTR
:
7727 var
= OMP_CLAUSE_DECL (c
);
7729 if (is_variable_sized (var
))
7731 tree new_var
= lookup_decl (var
, ctx
);
7732 tree pvar
= DECL_VALUE_EXPR (var
);
7733 gcc_assert (TREE_CODE (pvar
) == INDIRECT_REF
);
7734 pvar
= TREE_OPERAND (pvar
, 0);
7735 gcc_assert (DECL_P (pvar
));
7736 tree new_pvar
= lookup_decl (pvar
, ctx
);
7737 x
= build_fold_indirect_ref (new_pvar
);
7738 TREE_THIS_NOTRAP (x
) = 1;
7739 SET_DECL_VALUE_EXPR (new_var
, x
);
7740 DECL_HAS_VALUE_EXPR_P (new_var
) = 1;
7742 else if (TREE_CODE (TREE_TYPE (var
)) == ARRAY_TYPE
)
7744 tree new_var
= lookup_decl (var
, ctx
);
7745 tree type
= build_pointer_type (TREE_TYPE (var
));
7746 x
= create_tmp_var_raw (type
, get_name (new_var
));
7747 gimple_add_tmp_var (x
);
7748 x
= build_simple_mem_ref (x
);
7749 SET_DECL_VALUE_EXPR (new_var
, x
);
7750 DECL_HAS_VALUE_EXPR_P (new_var
) = 1;
7754 tree new_var
= lookup_decl (var
, ctx
);
7755 x
= create_tmp_var_raw (TREE_TYPE (new_var
), get_name (new_var
));
7756 gimple_add_tmp_var (x
);
7757 SET_DECL_VALUE_EXPR (new_var
, x
);
7758 DECL_HAS_VALUE_EXPR_P (new_var
) = 1;
7765 target_nesting_level
++;
7766 lower_omp (&tgt_body
, ctx
);
7767 target_nesting_level
--;
7769 else if (data_region
)
7770 lower_omp (&tgt_body
, ctx
);
7774 /* Declare all the variables created by mapping and the variables
7775 declared in the scope of the target body. */
7776 record_vars_into (ctx
->block_vars
, child_fn
);
7777 maybe_remove_omp_member_access_dummy_vars (tgt_bind
);
7778 record_vars_into (gimple_bind_vars (tgt_bind
), child_fn
);
7783 if (ctx
->record_type
)
7786 = create_tmp_var (ctx
->record_type
, ".omp_data_arr");
7787 DECL_NAMELESS (ctx
->sender_decl
) = 1;
7788 TREE_ADDRESSABLE (ctx
->sender_decl
) = 1;
7789 t
= make_tree_vec (3);
7790 TREE_VEC_ELT (t
, 0) = ctx
->sender_decl
;
7792 = create_tmp_var (build_array_type_nelts (size_type_node
, map_cnt
),
7794 DECL_NAMELESS (TREE_VEC_ELT (t
, 1)) = 1;
7795 TREE_ADDRESSABLE (TREE_VEC_ELT (t
, 1)) = 1;
7796 TREE_STATIC (TREE_VEC_ELT (t
, 1)) = 1;
7797 tree tkind_type
= short_unsigned_type_node
;
7798 int talign_shift
= 8;
7800 = create_tmp_var (build_array_type_nelts (tkind_type
, map_cnt
),
7802 DECL_NAMELESS (TREE_VEC_ELT (t
, 2)) = 1;
7803 TREE_ADDRESSABLE (TREE_VEC_ELT (t
, 2)) = 1;
7804 TREE_STATIC (TREE_VEC_ELT (t
, 2)) = 1;
7805 gimple_omp_target_set_data_arg (stmt
, t
);
7807 vec
<constructor_elt
, va_gc
> *vsize
;
7808 vec
<constructor_elt
, va_gc
> *vkind
;
7809 vec_alloc (vsize
, map_cnt
);
7810 vec_alloc (vkind
, map_cnt
);
7811 unsigned int map_idx
= 0;
7813 for (c
= clauses
; c
; c
= OMP_CLAUSE_CHAIN (c
))
7814 switch (OMP_CLAUSE_CODE (c
))
7816 tree ovar
, nc
, s
, purpose
, var
, x
, type
;
7817 unsigned int talign
;
7822 case OMP_CLAUSE_MAP
:
7824 case OMP_CLAUSE_FROM
:
7825 oacc_firstprivate_map
:
7827 ovar
= OMP_CLAUSE_DECL (c
);
7828 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_MAP
7829 && (OMP_CLAUSE_MAP_KIND (c
) == GOMP_MAP_FIRSTPRIVATE_POINTER
7830 || (OMP_CLAUSE_MAP_KIND (c
)
7831 == GOMP_MAP_FIRSTPRIVATE_REFERENCE
)))
7835 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_MAP
7836 && OMP_CLAUSE_MAP_ZERO_BIAS_ARRAY_SECTION (c
))
7838 gcc_checking_assert (OMP_CLAUSE_DECL (OMP_CLAUSE_CHAIN (c
))
7839 == get_base_address (ovar
));
7840 nc
= OMP_CLAUSE_CHAIN (c
);
7841 ovar
= OMP_CLAUSE_DECL (nc
);
7845 tree x
= build_sender_ref (ovar
, ctx
);
7847 = build_fold_addr_expr_with_type (ovar
, ptr_type_node
);
7848 gimplify_assign (x
, v
, &ilist
);
7854 if (DECL_SIZE (ovar
)
7855 && TREE_CODE (DECL_SIZE (ovar
)) != INTEGER_CST
)
7857 tree ovar2
= DECL_VALUE_EXPR (ovar
);
7858 gcc_assert (TREE_CODE (ovar2
) == INDIRECT_REF
);
7859 ovar2
= TREE_OPERAND (ovar2
, 0);
7860 gcc_assert (DECL_P (ovar2
));
7863 if (!maybe_lookup_field (ovar
, ctx
))
7867 talign
= TYPE_ALIGN_UNIT (TREE_TYPE (ovar
));
7868 if (DECL_P (ovar
) && DECL_ALIGN_UNIT (ovar
) > talign
)
7869 talign
= DECL_ALIGN_UNIT (ovar
);
7872 var
= lookup_decl_in_outer_ctx (ovar
, ctx
);
7873 x
= build_sender_ref (ovar
, ctx
);
7875 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_MAP
7876 && OMP_CLAUSE_MAP_KIND (c
) == GOMP_MAP_POINTER
7877 && !OMP_CLAUSE_MAP_ZERO_BIAS_ARRAY_SECTION (c
)
7878 && TREE_CODE (TREE_TYPE (ovar
)) == ARRAY_TYPE
)
7880 gcc_assert (offloaded
);
7882 = create_tmp_var (TREE_TYPE (TREE_TYPE (x
)));
7883 mark_addressable (avar
);
7884 gimplify_assign (avar
, build_fold_addr_expr (var
), &ilist
);
7885 talign
= DECL_ALIGN_UNIT (avar
);
7886 avar
= build_fold_addr_expr (avar
);
7887 gimplify_assign (x
, avar
, &ilist
);
7889 else if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_FIRSTPRIVATE
)
7891 gcc_assert (is_gimple_omp_oacc (ctx
->stmt
));
7892 if (!omp_is_reference (var
))
7894 if (is_gimple_reg (var
)
7895 && OMP_CLAUSE_FIRSTPRIVATE_IMPLICIT (c
))
7896 TREE_NO_WARNING (var
) = 1;
7897 var
= build_fold_addr_expr (var
);
7900 talign
= TYPE_ALIGN_UNIT (TREE_TYPE (TREE_TYPE (ovar
)));
7901 gimplify_assign (x
, var
, &ilist
);
7903 else if (is_gimple_reg (var
))
7905 gcc_assert (offloaded
);
7906 tree avar
= create_tmp_var (TREE_TYPE (var
));
7907 mark_addressable (avar
);
7908 enum gomp_map_kind map_kind
= OMP_CLAUSE_MAP_KIND (c
);
7909 if (GOMP_MAP_COPY_TO_P (map_kind
)
7910 || map_kind
== GOMP_MAP_POINTER
7911 || map_kind
== GOMP_MAP_TO_PSET
7912 || map_kind
== GOMP_MAP_FORCE_DEVICEPTR
)
7914 /* If we need to initialize a temporary
7915 with VAR because it is not addressable, and
7916 the variable hasn't been initialized yet, then
7917 we'll get a warning for the store to avar.
7918 Don't warn in that case, the mapping might
7920 TREE_NO_WARNING (var
) = 1;
7921 gimplify_assign (avar
, var
, &ilist
);
7923 avar
= build_fold_addr_expr (avar
);
7924 gimplify_assign (x
, avar
, &ilist
);
7925 if ((GOMP_MAP_COPY_FROM_P (map_kind
)
7926 || map_kind
== GOMP_MAP_FORCE_DEVICEPTR
)
7927 && !TYPE_READONLY (TREE_TYPE (var
)))
7929 x
= unshare_expr (x
);
7930 x
= build_simple_mem_ref (x
);
7931 gimplify_assign (var
, x
, &olist
);
7936 var
= build_fold_addr_expr (var
);
7937 gimplify_assign (x
, var
, &ilist
);
7941 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_FIRSTPRIVATE
)
7943 gcc_checking_assert (is_gimple_omp_oacc (ctx
->stmt
));
7944 s
= TREE_TYPE (ovar
);
7945 if (TREE_CODE (s
) == REFERENCE_TYPE
)
7947 s
= TYPE_SIZE_UNIT (s
);
7950 s
= OMP_CLAUSE_SIZE (c
);
7952 s
= TYPE_SIZE_UNIT (TREE_TYPE (ovar
));
7953 s
= fold_convert (size_type_node
, s
);
7954 purpose
= size_int (map_idx
++);
7955 CONSTRUCTOR_APPEND_ELT (vsize
, purpose
, s
);
7956 if (TREE_CODE (s
) != INTEGER_CST
)
7957 TREE_STATIC (TREE_VEC_ELT (t
, 1)) = 0;
7959 unsigned HOST_WIDE_INT tkind
, tkind_zero
;
7960 switch (OMP_CLAUSE_CODE (c
))
7962 case OMP_CLAUSE_MAP
:
7963 tkind
= OMP_CLAUSE_MAP_KIND (c
);
7965 if (OMP_CLAUSE_MAP_MAYBE_ZERO_LENGTH_ARRAY_SECTION (c
))
7968 case GOMP_MAP_ALLOC
:
7971 case GOMP_MAP_TOFROM
:
7972 case GOMP_MAP_ALWAYS_TO
:
7973 case GOMP_MAP_ALWAYS_FROM
:
7974 case GOMP_MAP_ALWAYS_TOFROM
:
7975 case GOMP_MAP_RELEASE
:
7976 case GOMP_MAP_FORCE_TO
:
7977 case GOMP_MAP_FORCE_FROM
:
7978 case GOMP_MAP_FORCE_TOFROM
:
7979 case GOMP_MAP_FORCE_PRESENT
:
7980 tkind_zero
= GOMP_MAP_ZERO_LEN_ARRAY_SECTION
;
7982 case GOMP_MAP_DELETE
:
7983 tkind_zero
= GOMP_MAP_DELETE_ZERO_LEN_ARRAY_SECTION
;
7987 if (tkind_zero
!= tkind
)
7989 if (integer_zerop (s
))
7991 else if (integer_nonzerop (s
))
7995 case OMP_CLAUSE_FIRSTPRIVATE
:
7996 gcc_checking_assert (is_gimple_omp_oacc (ctx
->stmt
));
7997 tkind
= GOMP_MAP_TO
;
8001 tkind
= GOMP_MAP_TO
;
8004 case OMP_CLAUSE_FROM
:
8005 tkind
= GOMP_MAP_FROM
;
8011 gcc_checking_assert (tkind
8012 < (HOST_WIDE_INT_C (1U) << talign_shift
));
8013 gcc_checking_assert (tkind_zero
8014 < (HOST_WIDE_INT_C (1U) << talign_shift
));
8015 talign
= ceil_log2 (talign
);
8016 tkind
|= talign
<< talign_shift
;
8017 tkind_zero
|= talign
<< talign_shift
;
8018 gcc_checking_assert (tkind
8019 <= tree_to_uhwi (TYPE_MAX_VALUE (tkind_type
)));
8020 gcc_checking_assert (tkind_zero
8021 <= tree_to_uhwi (TYPE_MAX_VALUE (tkind_type
)));
8022 if (tkind
== tkind_zero
)
8023 x
= build_int_cstu (tkind_type
, tkind
);
8026 TREE_STATIC (TREE_VEC_ELT (t
, 2)) = 0;
8027 x
= build3 (COND_EXPR
, tkind_type
,
8028 fold_build2 (EQ_EXPR
, boolean_type_node
,
8029 unshare_expr (s
), size_zero_node
),
8030 build_int_cstu (tkind_type
, tkind_zero
),
8031 build_int_cstu (tkind_type
, tkind
));
8033 CONSTRUCTOR_APPEND_ELT (vkind
, purpose
, x
);
8038 case OMP_CLAUSE_FIRSTPRIVATE
:
8039 if (is_oacc_parallel (ctx
))
8040 goto oacc_firstprivate_map
;
8041 ovar
= OMP_CLAUSE_DECL (c
);
8042 if (omp_is_reference (ovar
))
8043 talign
= TYPE_ALIGN_UNIT (TREE_TYPE (TREE_TYPE (ovar
)));
8045 talign
= DECL_ALIGN_UNIT (ovar
);
8046 var
= lookup_decl_in_outer_ctx (ovar
, ctx
);
8047 x
= build_sender_ref (ovar
, ctx
);
8048 tkind
= GOMP_MAP_FIRSTPRIVATE
;
8049 type
= TREE_TYPE (ovar
);
8050 if (omp_is_reference (ovar
))
8051 type
= TREE_TYPE (type
);
8052 if ((INTEGRAL_TYPE_P (type
)
8053 && TYPE_PRECISION (type
) <= POINTER_SIZE
)
8054 || TREE_CODE (type
) == POINTER_TYPE
)
8056 tkind
= GOMP_MAP_FIRSTPRIVATE_INT
;
8058 if (omp_is_reference (var
))
8059 t
= build_simple_mem_ref (var
);
8060 else if (OMP_CLAUSE_FIRSTPRIVATE_IMPLICIT (c
))
8061 TREE_NO_WARNING (var
) = 1;
8062 if (TREE_CODE (type
) != POINTER_TYPE
)
8063 t
= fold_convert (pointer_sized_int_node
, t
);
8064 t
= fold_convert (TREE_TYPE (x
), t
);
8065 gimplify_assign (x
, t
, &ilist
);
8067 else if (omp_is_reference (var
))
8068 gimplify_assign (x
, var
, &ilist
);
8069 else if (is_gimple_reg (var
))
8071 tree avar
= create_tmp_var (TREE_TYPE (var
));
8072 mark_addressable (avar
);
8073 if (OMP_CLAUSE_FIRSTPRIVATE_IMPLICIT (c
))
8074 TREE_NO_WARNING (var
) = 1;
8075 gimplify_assign (avar
, var
, &ilist
);
8076 avar
= build_fold_addr_expr (avar
);
8077 gimplify_assign (x
, avar
, &ilist
);
8081 var
= build_fold_addr_expr (var
);
8082 gimplify_assign (x
, var
, &ilist
);
8084 if (tkind
== GOMP_MAP_FIRSTPRIVATE_INT
)
8086 else if (omp_is_reference (ovar
))
8087 s
= TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (ovar
)));
8089 s
= TYPE_SIZE_UNIT (TREE_TYPE (ovar
));
8090 s
= fold_convert (size_type_node
, s
);
8091 purpose
= size_int (map_idx
++);
8092 CONSTRUCTOR_APPEND_ELT (vsize
, purpose
, s
);
8093 if (TREE_CODE (s
) != INTEGER_CST
)
8094 TREE_STATIC (TREE_VEC_ELT (t
, 1)) = 0;
8096 gcc_checking_assert (tkind
8097 < (HOST_WIDE_INT_C (1U) << talign_shift
));
8098 talign
= ceil_log2 (talign
);
8099 tkind
|= talign
<< talign_shift
;
8100 gcc_checking_assert (tkind
8101 <= tree_to_uhwi (TYPE_MAX_VALUE (tkind_type
)));
8102 CONSTRUCTOR_APPEND_ELT (vkind
, purpose
,
8103 build_int_cstu (tkind_type
, tkind
));
8106 case OMP_CLAUSE_USE_DEVICE_PTR
:
8107 case OMP_CLAUSE_IS_DEVICE_PTR
:
8108 ovar
= OMP_CLAUSE_DECL (c
);
8109 var
= lookup_decl_in_outer_ctx (ovar
, ctx
);
8110 x
= build_sender_ref (ovar
, ctx
);
8111 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_USE_DEVICE_PTR
)
8112 tkind
= GOMP_MAP_USE_DEVICE_PTR
;
8114 tkind
= GOMP_MAP_FIRSTPRIVATE_INT
;
8115 type
= TREE_TYPE (ovar
);
8116 if (TREE_CODE (type
) == ARRAY_TYPE
)
8117 var
= build_fold_addr_expr (var
);
8120 if (omp_is_reference (ovar
))
8122 type
= TREE_TYPE (type
);
8123 if (TREE_CODE (type
) != ARRAY_TYPE
)
8124 var
= build_simple_mem_ref (var
);
8125 var
= fold_convert (TREE_TYPE (x
), var
);
8128 gimplify_assign (x
, var
, &ilist
);
8130 purpose
= size_int (map_idx
++);
8131 CONSTRUCTOR_APPEND_ELT (vsize
, purpose
, s
);
8132 gcc_checking_assert (tkind
8133 < (HOST_WIDE_INT_C (1U) << talign_shift
));
8134 gcc_checking_assert (tkind
8135 <= tree_to_uhwi (TYPE_MAX_VALUE (tkind_type
)));
8136 CONSTRUCTOR_APPEND_ELT (vkind
, purpose
,
8137 build_int_cstu (tkind_type
, tkind
));
8141 gcc_assert (map_idx
== map_cnt
);
8143 DECL_INITIAL (TREE_VEC_ELT (t
, 1))
8144 = build_constructor (TREE_TYPE (TREE_VEC_ELT (t
, 1)), vsize
);
8145 DECL_INITIAL (TREE_VEC_ELT (t
, 2))
8146 = build_constructor (TREE_TYPE (TREE_VEC_ELT (t
, 2)), vkind
);
8147 for (int i
= 1; i
<= 2; i
++)
8148 if (!TREE_STATIC (TREE_VEC_ELT (t
, i
)))
8150 gimple_seq initlist
= NULL
;
8151 force_gimple_operand (build1 (DECL_EXPR
, void_type_node
,
8152 TREE_VEC_ELT (t
, i
)),
8153 &initlist
, true, NULL_TREE
);
8154 gimple_seq_add_seq (&ilist
, initlist
);
8156 tree clobber
= build_constructor (TREE_TYPE (TREE_VEC_ELT (t
, i
)),
8158 TREE_THIS_VOLATILE (clobber
) = 1;
8159 gimple_seq_add_stmt (&olist
,
8160 gimple_build_assign (TREE_VEC_ELT (t
, i
),
8164 tree clobber
= build_constructor (ctx
->record_type
, NULL
);
8165 TREE_THIS_VOLATILE (clobber
) = 1;
8166 gimple_seq_add_stmt (&olist
, gimple_build_assign (ctx
->sender_decl
,
8170 /* Once all the expansions are done, sequence all the different
8171 fragments inside gimple_omp_body. */
8176 && ctx
->record_type
)
8178 t
= build_fold_addr_expr_loc (loc
, ctx
->sender_decl
);
8179 /* fixup_child_record_type might have changed receiver_decl's type. */
8180 t
= fold_convert_loc (loc
, TREE_TYPE (ctx
->receiver_decl
), t
);
8181 gimple_seq_add_stmt (&new_body
,
8182 gimple_build_assign (ctx
->receiver_decl
, t
));
8184 gimple_seq_add_seq (&new_body
, fplist
);
8186 if (offloaded
|| data_region
)
8188 tree prev
= NULL_TREE
;
8189 for (c
= clauses
; c
; c
= OMP_CLAUSE_CHAIN (c
))
8190 switch (OMP_CLAUSE_CODE (c
))
8195 case OMP_CLAUSE_FIRSTPRIVATE
:
8196 if (is_gimple_omp_oacc (ctx
->stmt
))
8198 var
= OMP_CLAUSE_DECL (c
);
8199 if (omp_is_reference (var
)
8200 || is_gimple_reg_type (TREE_TYPE (var
)))
8202 tree new_var
= lookup_decl (var
, ctx
);
8204 type
= TREE_TYPE (var
);
8205 if (omp_is_reference (var
))
8206 type
= TREE_TYPE (type
);
8207 if ((INTEGRAL_TYPE_P (type
)
8208 && TYPE_PRECISION (type
) <= POINTER_SIZE
)
8209 || TREE_CODE (type
) == POINTER_TYPE
)
8211 x
= build_receiver_ref (var
, false, ctx
);
8212 if (TREE_CODE (type
) != POINTER_TYPE
)
8213 x
= fold_convert (pointer_sized_int_node
, x
);
8214 x
= fold_convert (type
, x
);
8215 gimplify_expr (&x
, &new_body
, NULL
, is_gimple_val
,
8217 if (omp_is_reference (var
))
8219 tree v
= create_tmp_var_raw (type
, get_name (var
));
8220 gimple_add_tmp_var (v
);
8221 TREE_ADDRESSABLE (v
) = 1;
8222 gimple_seq_add_stmt (&new_body
,
8223 gimple_build_assign (v
, x
));
8224 x
= build_fold_addr_expr (v
);
8226 gimple_seq_add_stmt (&new_body
,
8227 gimple_build_assign (new_var
, x
));
8231 x
= build_receiver_ref (var
, !omp_is_reference (var
), ctx
);
8232 gimplify_expr (&x
, &new_body
, NULL
, is_gimple_val
,
8234 gimple_seq_add_stmt (&new_body
,
8235 gimple_build_assign (new_var
, x
));
8238 else if (is_variable_sized (var
))
8240 tree pvar
= DECL_VALUE_EXPR (var
);
8241 gcc_assert (TREE_CODE (pvar
) == INDIRECT_REF
);
8242 pvar
= TREE_OPERAND (pvar
, 0);
8243 gcc_assert (DECL_P (pvar
));
8244 tree new_var
= lookup_decl (pvar
, ctx
);
8245 x
= build_receiver_ref (var
, false, ctx
);
8246 gimplify_expr (&x
, &new_body
, NULL
, is_gimple_val
, fb_rvalue
);
8247 gimple_seq_add_stmt (&new_body
,
8248 gimple_build_assign (new_var
, x
));
8251 case OMP_CLAUSE_PRIVATE
:
8252 if (is_gimple_omp_oacc (ctx
->stmt
))
8254 var
= OMP_CLAUSE_DECL (c
);
8255 if (omp_is_reference (var
))
8257 location_t clause_loc
= OMP_CLAUSE_LOCATION (c
);
8258 tree new_var
= lookup_decl (var
, ctx
);
8259 x
= TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (new_var
)));
8260 if (TREE_CONSTANT (x
))
8262 x
= create_tmp_var_raw (TREE_TYPE (TREE_TYPE (new_var
)),
8264 gimple_add_tmp_var (x
);
8265 TREE_ADDRESSABLE (x
) = 1;
8266 x
= build_fold_addr_expr_loc (clause_loc
, x
);
8271 x
= fold_convert_loc (clause_loc
, TREE_TYPE (new_var
), x
);
8272 gimplify_expr (&x
, &new_body
, NULL
, is_gimple_val
, fb_rvalue
);
8273 gimple_seq_add_stmt (&new_body
,
8274 gimple_build_assign (new_var
, x
));
8277 case OMP_CLAUSE_USE_DEVICE_PTR
:
8278 case OMP_CLAUSE_IS_DEVICE_PTR
:
8279 var
= OMP_CLAUSE_DECL (c
);
8280 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_USE_DEVICE_PTR
)
8281 x
= build_sender_ref (var
, ctx
);
8283 x
= build_receiver_ref (var
, false, ctx
);
8284 if (is_variable_sized (var
))
8286 tree pvar
= DECL_VALUE_EXPR (var
);
8287 gcc_assert (TREE_CODE (pvar
) == INDIRECT_REF
);
8288 pvar
= TREE_OPERAND (pvar
, 0);
8289 gcc_assert (DECL_P (pvar
));
8290 tree new_var
= lookup_decl (pvar
, ctx
);
8291 gimplify_expr (&x
, &new_body
, NULL
, is_gimple_val
, fb_rvalue
);
8292 gimple_seq_add_stmt (&new_body
,
8293 gimple_build_assign (new_var
, x
));
8295 else if (TREE_CODE (TREE_TYPE (var
)) == ARRAY_TYPE
)
8297 tree new_var
= lookup_decl (var
, ctx
);
8298 new_var
= DECL_VALUE_EXPR (new_var
);
8299 gcc_assert (TREE_CODE (new_var
) == MEM_REF
);
8300 new_var
= TREE_OPERAND (new_var
, 0);
8301 gcc_assert (DECL_P (new_var
));
8302 gimplify_expr (&x
, &new_body
, NULL
, is_gimple_val
, fb_rvalue
);
8303 gimple_seq_add_stmt (&new_body
,
8304 gimple_build_assign (new_var
, x
));
8308 tree type
= TREE_TYPE (var
);
8309 tree new_var
= lookup_decl (var
, ctx
);
8310 if (omp_is_reference (var
))
8312 type
= TREE_TYPE (type
);
8313 if (TREE_CODE (type
) != ARRAY_TYPE
)
8315 tree v
= create_tmp_var_raw (type
, get_name (var
));
8316 gimple_add_tmp_var (v
);
8317 TREE_ADDRESSABLE (v
) = 1;
8318 x
= fold_convert (type
, x
);
8319 gimplify_expr (&x
, &new_body
, NULL
, is_gimple_val
,
8321 gimple_seq_add_stmt (&new_body
,
8322 gimple_build_assign (v
, x
));
8323 x
= build_fold_addr_expr (v
);
8326 new_var
= DECL_VALUE_EXPR (new_var
);
8327 x
= fold_convert (TREE_TYPE (new_var
), x
);
8328 gimplify_expr (&x
, &new_body
, NULL
, is_gimple_val
, fb_rvalue
);
8329 gimple_seq_add_stmt (&new_body
,
8330 gimple_build_assign (new_var
, x
));
8334 /* Handle GOMP_MAP_FIRSTPRIVATE_{POINTER,REFERENCE} in second pass,
8335 so that firstprivate vars holding OMP_CLAUSE_SIZE if needed
8336 are already handled. Similarly OMP_CLAUSE_PRIVATE for VLAs
8337 or references to VLAs. */
8338 for (c
= clauses
; c
; c
= OMP_CLAUSE_CHAIN (c
))
8339 switch (OMP_CLAUSE_CODE (c
))
8344 case OMP_CLAUSE_MAP
:
8345 if (OMP_CLAUSE_MAP_KIND (c
) == GOMP_MAP_FIRSTPRIVATE_POINTER
8346 || OMP_CLAUSE_MAP_KIND (c
) == GOMP_MAP_FIRSTPRIVATE_REFERENCE
)
8348 location_t clause_loc
= OMP_CLAUSE_LOCATION (c
);
8349 poly_int64 offset
= 0;
8351 var
= OMP_CLAUSE_DECL (c
);
8353 && TREE_CODE (TREE_TYPE (var
)) == ARRAY_TYPE
8354 && is_global_var (maybe_lookup_decl_in_outer_ctx (var
,
8356 && varpool_node::get_create (var
)->offloadable
)
8358 if (TREE_CODE (var
) == INDIRECT_REF
8359 && TREE_CODE (TREE_OPERAND (var
, 0)) == COMPONENT_REF
)
8360 var
= TREE_OPERAND (var
, 0);
8361 if (TREE_CODE (var
) == COMPONENT_REF
)
8363 var
= get_addr_base_and_unit_offset (var
, &offset
);
8364 gcc_assert (var
!= NULL_TREE
&& DECL_P (var
));
8366 else if (DECL_SIZE (var
)
8367 && TREE_CODE (DECL_SIZE (var
)) != INTEGER_CST
)
8369 tree var2
= DECL_VALUE_EXPR (var
);
8370 gcc_assert (TREE_CODE (var2
) == INDIRECT_REF
);
8371 var2
= TREE_OPERAND (var2
, 0);
8372 gcc_assert (DECL_P (var2
));
8375 tree new_var
= lookup_decl (var
, ctx
), x
;
8376 tree type
= TREE_TYPE (new_var
);
8378 if (TREE_CODE (OMP_CLAUSE_DECL (c
)) == INDIRECT_REF
8379 && (TREE_CODE (TREE_OPERAND (OMP_CLAUSE_DECL (c
), 0))
8382 type
= TREE_TYPE (TREE_OPERAND (OMP_CLAUSE_DECL (c
), 0));
8384 new_var
= build2 (MEM_REF
, type
,
8385 build_fold_addr_expr (new_var
),
8386 build_int_cst (build_pointer_type (type
),
8389 else if (TREE_CODE (OMP_CLAUSE_DECL (c
)) == COMPONENT_REF
)
8391 type
= TREE_TYPE (OMP_CLAUSE_DECL (c
));
8392 is_ref
= TREE_CODE (type
) == REFERENCE_TYPE
;
8393 new_var
= build2 (MEM_REF
, type
,
8394 build_fold_addr_expr (new_var
),
8395 build_int_cst (build_pointer_type (type
),
8399 is_ref
= omp_is_reference (var
);
8400 if (OMP_CLAUSE_MAP_KIND (c
) == GOMP_MAP_FIRSTPRIVATE_REFERENCE
)
8402 bool ref_to_array
= false;
8405 type
= TREE_TYPE (type
);
8406 if (TREE_CODE (type
) == ARRAY_TYPE
)
8408 type
= build_pointer_type (type
);
8409 ref_to_array
= true;
8412 else if (TREE_CODE (type
) == ARRAY_TYPE
)
8414 tree decl2
= DECL_VALUE_EXPR (new_var
);
8415 gcc_assert (TREE_CODE (decl2
) == MEM_REF
);
8416 decl2
= TREE_OPERAND (decl2
, 0);
8417 gcc_assert (DECL_P (decl2
));
8419 type
= TREE_TYPE (new_var
);
8421 x
= build_receiver_ref (OMP_CLAUSE_DECL (prev
), false, ctx
);
8422 x
= fold_convert_loc (clause_loc
, type
, x
);
8423 if (!integer_zerop (OMP_CLAUSE_SIZE (c
)))
8425 tree bias
= OMP_CLAUSE_SIZE (c
);
8427 bias
= lookup_decl (bias
, ctx
);
8428 bias
= fold_convert_loc (clause_loc
, sizetype
, bias
);
8429 bias
= fold_build1_loc (clause_loc
, NEGATE_EXPR
, sizetype
,
8431 x
= fold_build2_loc (clause_loc
, POINTER_PLUS_EXPR
,
8432 TREE_TYPE (x
), x
, bias
);
8435 x
= fold_convert_loc (clause_loc
, TREE_TYPE (new_var
), x
);
8436 gimplify_expr (&x
, &new_body
, NULL
, is_gimple_val
, fb_rvalue
);
8437 if (is_ref
&& !ref_to_array
)
8439 tree t
= create_tmp_var_raw (type
, get_name (var
));
8440 gimple_add_tmp_var (t
);
8441 TREE_ADDRESSABLE (t
) = 1;
8442 gimple_seq_add_stmt (&new_body
,
8443 gimple_build_assign (t
, x
));
8444 x
= build_fold_addr_expr_loc (clause_loc
, t
);
8446 gimple_seq_add_stmt (&new_body
,
8447 gimple_build_assign (new_var
, x
));
8450 else if (OMP_CLAUSE_CHAIN (c
)
8451 && OMP_CLAUSE_CODE (OMP_CLAUSE_CHAIN (c
))
8453 && (OMP_CLAUSE_MAP_KIND (OMP_CLAUSE_CHAIN (c
))
8454 == GOMP_MAP_FIRSTPRIVATE_POINTER
8455 || (OMP_CLAUSE_MAP_KIND (OMP_CLAUSE_CHAIN (c
))
8456 == GOMP_MAP_FIRSTPRIVATE_REFERENCE
)))
8459 case OMP_CLAUSE_PRIVATE
:
8460 var
= OMP_CLAUSE_DECL (c
);
8461 if (is_variable_sized (var
))
8463 location_t clause_loc
= OMP_CLAUSE_LOCATION (c
);
8464 tree new_var
= lookup_decl (var
, ctx
);
8465 tree pvar
= DECL_VALUE_EXPR (var
);
8466 gcc_assert (TREE_CODE (pvar
) == INDIRECT_REF
);
8467 pvar
= TREE_OPERAND (pvar
, 0);
8468 gcc_assert (DECL_P (pvar
));
8469 tree new_pvar
= lookup_decl (pvar
, ctx
);
8470 tree atmp
= builtin_decl_explicit (BUILT_IN_ALLOCA_WITH_ALIGN
);
8471 tree al
= size_int (DECL_ALIGN (var
));
8472 tree x
= TYPE_SIZE_UNIT (TREE_TYPE (new_var
));
8473 x
= build_call_expr_loc (clause_loc
, atmp
, 2, x
, al
);
8474 x
= fold_convert_loc (clause_loc
, TREE_TYPE (new_pvar
), x
);
8475 gimplify_expr (&x
, &new_body
, NULL
, is_gimple_val
, fb_rvalue
);
8476 gimple_seq_add_stmt (&new_body
,
8477 gimple_build_assign (new_pvar
, x
));
8479 else if (omp_is_reference (var
) && !is_gimple_omp_oacc (ctx
->stmt
))
8481 location_t clause_loc
= OMP_CLAUSE_LOCATION (c
);
8482 tree new_var
= lookup_decl (var
, ctx
);
8483 tree x
= TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (new_var
)));
8484 if (TREE_CONSTANT (x
))
8489 = builtin_decl_explicit (BUILT_IN_ALLOCA_WITH_ALIGN
);
8490 tree rtype
= TREE_TYPE (TREE_TYPE (new_var
));
8491 tree al
= size_int (TYPE_ALIGN (rtype
));
8492 x
= build_call_expr_loc (clause_loc
, atmp
, 2, x
, al
);
8495 x
= fold_convert_loc (clause_loc
, TREE_TYPE (new_var
), x
);
8496 gimplify_expr (&x
, &new_body
, NULL
, is_gimple_val
, fb_rvalue
);
8497 gimple_seq_add_stmt (&new_body
,
8498 gimple_build_assign (new_var
, x
));
8503 gimple_seq fork_seq
= NULL
;
8504 gimple_seq join_seq
= NULL
;
8506 if (is_oacc_parallel (ctx
))
8508 /* If there are reductions on the offloaded region itself, treat
8509 them as a dummy GANG loop. */
8510 tree level
= build_int_cst (integer_type_node
, GOMP_DIM_GANG
);
8512 lower_oacc_reductions (gimple_location (ctx
->stmt
), clauses
, level
,
8513 false, NULL
, NULL
, &fork_seq
, &join_seq
, ctx
);
8516 gimple_seq_add_seq (&new_body
, fork_seq
);
8517 gimple_seq_add_seq (&new_body
, tgt_body
);
8518 gimple_seq_add_seq (&new_body
, join_seq
);
8521 new_body
= maybe_catch_exception (new_body
);
8523 gimple_seq_add_stmt (&new_body
, gimple_build_omp_return (false));
8524 gimple_omp_set_body (stmt
, new_body
);
8527 bind
= gimple_build_bind (NULL
, NULL
,
8528 tgt_bind
? gimple_bind_block (tgt_bind
)
8530 gsi_replace (gsi_p
, dep_bind
? dep_bind
: bind
, true);
8531 gimple_bind_add_seq (bind
, ilist
);
8532 gimple_bind_add_stmt (bind
, stmt
);
8533 gimple_bind_add_seq (bind
, olist
);
8535 pop_gimplify_context (NULL
);
8539 gimple_bind_add_seq (dep_bind
, dep_ilist
);
8540 gimple_bind_add_stmt (dep_bind
, bind
);
8541 gimple_bind_add_seq (dep_bind
, dep_olist
);
8542 pop_gimplify_context (dep_bind
);
8546 /* Expand code for an OpenMP teams directive. */
8549 lower_omp_teams (gimple_stmt_iterator
*gsi_p
, omp_context
*ctx
)
8551 gomp_teams
*teams_stmt
= as_a
<gomp_teams
*> (gsi_stmt (*gsi_p
));
8552 push_gimplify_context ();
8554 tree block
= make_node (BLOCK
);
8555 gbind
*bind
= gimple_build_bind (NULL
, NULL
, block
);
8556 gsi_replace (gsi_p
, bind
, true);
8557 gimple_seq bind_body
= NULL
;
8558 gimple_seq dlist
= NULL
;
8559 gimple_seq olist
= NULL
;
8561 tree num_teams
= omp_find_clause (gimple_omp_teams_clauses (teams_stmt
),
8562 OMP_CLAUSE_NUM_TEAMS
);
8563 if (num_teams
== NULL_TREE
)
8564 num_teams
= build_int_cst (unsigned_type_node
, 0);
8567 num_teams
= OMP_CLAUSE_NUM_TEAMS_EXPR (num_teams
);
8568 num_teams
= fold_convert (unsigned_type_node
, num_teams
);
8569 gimplify_expr (&num_teams
, &bind_body
, NULL
, is_gimple_val
, fb_rvalue
);
8571 tree thread_limit
= omp_find_clause (gimple_omp_teams_clauses (teams_stmt
),
8572 OMP_CLAUSE_THREAD_LIMIT
);
8573 if (thread_limit
== NULL_TREE
)
8574 thread_limit
= build_int_cst (unsigned_type_node
, 0);
8577 thread_limit
= OMP_CLAUSE_THREAD_LIMIT_EXPR (thread_limit
);
8578 thread_limit
= fold_convert (unsigned_type_node
, thread_limit
);
8579 gimplify_expr (&thread_limit
, &bind_body
, NULL
, is_gimple_val
,
8583 lower_rec_input_clauses (gimple_omp_teams_clauses (teams_stmt
),
8584 &bind_body
, &dlist
, ctx
, NULL
);
8585 lower_omp (gimple_omp_body_ptr (teams_stmt
), ctx
);
8586 lower_reduction_clauses (gimple_omp_teams_clauses (teams_stmt
), &olist
, ctx
);
8587 if (!gimple_omp_teams_grid_phony (teams_stmt
))
8589 gimple_seq_add_stmt (&bind_body
, teams_stmt
);
8590 location_t loc
= gimple_location (teams_stmt
);
8591 tree decl
= builtin_decl_explicit (BUILT_IN_GOMP_TEAMS
);
8592 gimple
*call
= gimple_build_call (decl
, 2, num_teams
, thread_limit
);
8593 gimple_set_location (call
, loc
);
8594 gimple_seq_add_stmt (&bind_body
, call
);
8597 gimple_seq_add_seq (&bind_body
, gimple_omp_body (teams_stmt
));
8598 gimple_omp_set_body (teams_stmt
, NULL
);
8599 gimple_seq_add_seq (&bind_body
, olist
);
8600 gimple_seq_add_seq (&bind_body
, dlist
);
8601 if (!gimple_omp_teams_grid_phony (teams_stmt
))
8602 gimple_seq_add_stmt (&bind_body
, gimple_build_omp_return (true));
8603 gimple_bind_set_body (bind
, bind_body
);
8605 pop_gimplify_context (bind
);
8607 gimple_bind_append_vars (bind
, ctx
->block_vars
);
8608 BLOCK_VARS (block
) = ctx
->block_vars
;
8609 if (BLOCK_VARS (block
))
8610 TREE_USED (block
) = 1;
8613 /* Expand code within an artificial GIMPLE_OMP_GRID_BODY OMP construct. */
8616 lower_omp_grid_body (gimple_stmt_iterator
*gsi_p
, omp_context
*ctx
)
8618 gimple
*stmt
= gsi_stmt (*gsi_p
);
8619 lower_omp (gimple_omp_body_ptr (stmt
), ctx
);
8620 gimple_seq_add_stmt (gimple_omp_body_ptr (stmt
),
8621 gimple_build_omp_return (false));
8625 /* Callback for lower_omp_1. Return non-NULL if *tp needs to be
8626 regimplified. If DATA is non-NULL, lower_omp_1 is outside
8627 of OMP context, but with task_shared_vars set. */
8630 lower_omp_regimplify_p (tree
*tp
, int *walk_subtrees
,
8635 /* Any variable with DECL_VALUE_EXPR needs to be regimplified. */
8636 if (VAR_P (t
) && data
== NULL
&& DECL_HAS_VALUE_EXPR_P (t
))
8639 if (task_shared_vars
8641 && bitmap_bit_p (task_shared_vars
, DECL_UID (t
)))
8644 /* If a global variable has been privatized, TREE_CONSTANT on
8645 ADDR_EXPR might be wrong. */
8646 if (data
== NULL
&& TREE_CODE (t
) == ADDR_EXPR
)
8647 recompute_tree_invariant_for_addr_expr (t
);
8649 *walk_subtrees
= !IS_TYPE_OR_DECL_P (t
);
8653 /* Data to be communicated between lower_omp_regimplify_operands and
8654 lower_omp_regimplify_operands_p. */
8656 struct lower_omp_regimplify_operands_data
8662 /* Helper function for lower_omp_regimplify_operands. Find
8663 omp_member_access_dummy_var vars and adjust temporarily their
8664 DECL_VALUE_EXPRs if needed. */
8667 lower_omp_regimplify_operands_p (tree
*tp
, int *walk_subtrees
,
8670 tree t
= omp_member_access_dummy_var (*tp
);
8673 struct walk_stmt_info
*wi
= (struct walk_stmt_info
*) data
;
8674 lower_omp_regimplify_operands_data
*ldata
8675 = (lower_omp_regimplify_operands_data
*) wi
->info
;
8676 tree o
= maybe_lookup_decl (t
, ldata
->ctx
);
8679 ldata
->decls
->safe_push (DECL_VALUE_EXPR (*tp
));
8680 ldata
->decls
->safe_push (*tp
);
8681 tree v
= unshare_and_remap (DECL_VALUE_EXPR (*tp
), t
, o
);
8682 SET_DECL_VALUE_EXPR (*tp
, v
);
8685 *walk_subtrees
= !IS_TYPE_OR_DECL_P (*tp
);
8689 /* Wrapper around gimple_regimplify_operands that adjusts DECL_VALUE_EXPRs
8690 of omp_member_access_dummy_var vars during regimplification. */
8693 lower_omp_regimplify_operands (omp_context
*ctx
, gimple
*stmt
,
8694 gimple_stmt_iterator
*gsi_p
)
8696 auto_vec
<tree
, 10> decls
;
8699 struct walk_stmt_info wi
;
8700 memset (&wi
, '\0', sizeof (wi
));
8701 struct lower_omp_regimplify_operands_data data
;
8703 data
.decls
= &decls
;
8705 walk_gimple_op (stmt
, lower_omp_regimplify_operands_p
, &wi
);
8707 gimple_regimplify_operands (stmt
, gsi_p
);
8708 while (!decls
.is_empty ())
8710 tree t
= decls
.pop ();
8711 tree v
= decls
.pop ();
8712 SET_DECL_VALUE_EXPR (t
, v
);
8717 lower_omp_1 (gimple_stmt_iterator
*gsi_p
, omp_context
*ctx
)
8719 gimple
*stmt
= gsi_stmt (*gsi_p
);
8720 struct walk_stmt_info wi
;
8723 if (gimple_has_location (stmt
))
8724 input_location
= gimple_location (stmt
);
8726 if (task_shared_vars
)
8727 memset (&wi
, '\0', sizeof (wi
));
8729 /* If we have issued syntax errors, avoid doing any heavy lifting.
8730 Just replace the OMP directives with a NOP to avoid
8731 confusing RTL expansion. */
8732 if (seen_error () && is_gimple_omp (stmt
))
8734 gsi_replace (gsi_p
, gimple_build_nop (), true);
8738 switch (gimple_code (stmt
))
8742 gcond
*cond_stmt
= as_a
<gcond
*> (stmt
);
8743 if ((ctx
|| task_shared_vars
)
8744 && (walk_tree (gimple_cond_lhs_ptr (cond_stmt
),
8745 lower_omp_regimplify_p
,
8746 ctx
? NULL
: &wi
, NULL
)
8747 || walk_tree (gimple_cond_rhs_ptr (cond_stmt
),
8748 lower_omp_regimplify_p
,
8749 ctx
? NULL
: &wi
, NULL
)))
8750 lower_omp_regimplify_operands (ctx
, cond_stmt
, gsi_p
);
8754 lower_omp (gimple_catch_handler_ptr (as_a
<gcatch
*> (stmt
)), ctx
);
8756 case GIMPLE_EH_FILTER
:
8757 lower_omp (gimple_eh_filter_failure_ptr (stmt
), ctx
);
8760 lower_omp (gimple_try_eval_ptr (stmt
), ctx
);
8761 lower_omp (gimple_try_cleanup_ptr (stmt
), ctx
);
8763 case GIMPLE_TRANSACTION
:
8764 lower_omp (gimple_transaction_body_ptr (as_a
<gtransaction
*> (stmt
)),
8768 lower_omp (gimple_bind_body_ptr (as_a
<gbind
*> (stmt
)), ctx
);
8769 maybe_remove_omp_member_access_dummy_vars (as_a
<gbind
*> (stmt
));
8771 case GIMPLE_OMP_PARALLEL
:
8772 case GIMPLE_OMP_TASK
:
8773 ctx
= maybe_lookup_ctx (stmt
);
8775 if (ctx
->cancellable
)
8776 ctx
->cancel_label
= create_artificial_label (UNKNOWN_LOCATION
);
8777 lower_omp_taskreg (gsi_p
, ctx
);
8779 case GIMPLE_OMP_FOR
:
8780 ctx
= maybe_lookup_ctx (stmt
);
8782 if (ctx
->cancellable
)
8783 ctx
->cancel_label
= create_artificial_label (UNKNOWN_LOCATION
);
8784 lower_omp_for (gsi_p
, ctx
);
8786 case GIMPLE_OMP_SECTIONS
:
8787 ctx
= maybe_lookup_ctx (stmt
);
8789 if (ctx
->cancellable
)
8790 ctx
->cancel_label
= create_artificial_label (UNKNOWN_LOCATION
);
8791 lower_omp_sections (gsi_p
, ctx
);
8793 case GIMPLE_OMP_SINGLE
:
8794 ctx
= maybe_lookup_ctx (stmt
);
8796 lower_omp_single (gsi_p
, ctx
);
8798 case GIMPLE_OMP_MASTER
:
8799 ctx
= maybe_lookup_ctx (stmt
);
8801 lower_omp_master (gsi_p
, ctx
);
8803 case GIMPLE_OMP_TASKGROUP
:
8804 ctx
= maybe_lookup_ctx (stmt
);
8806 lower_omp_taskgroup (gsi_p
, ctx
);
8808 case GIMPLE_OMP_ORDERED
:
8809 ctx
= maybe_lookup_ctx (stmt
);
8811 lower_omp_ordered (gsi_p
, ctx
);
8813 case GIMPLE_OMP_CRITICAL
:
8814 ctx
= maybe_lookup_ctx (stmt
);
8816 lower_omp_critical (gsi_p
, ctx
);
8818 case GIMPLE_OMP_ATOMIC_LOAD
:
8819 if ((ctx
|| task_shared_vars
)
8820 && walk_tree (gimple_omp_atomic_load_rhs_ptr (
8821 as_a
<gomp_atomic_load
*> (stmt
)),
8822 lower_omp_regimplify_p
, ctx
? NULL
: &wi
, NULL
))
8823 lower_omp_regimplify_operands (ctx
, stmt
, gsi_p
);
8825 case GIMPLE_OMP_TARGET
:
8826 ctx
= maybe_lookup_ctx (stmt
);
8828 lower_omp_target (gsi_p
, ctx
);
8830 case GIMPLE_OMP_TEAMS
:
8831 ctx
= maybe_lookup_ctx (stmt
);
8833 lower_omp_teams (gsi_p
, ctx
);
8835 case GIMPLE_OMP_GRID_BODY
:
8836 ctx
= maybe_lookup_ctx (stmt
);
8838 lower_omp_grid_body (gsi_p
, ctx
);
8842 call_stmt
= as_a
<gcall
*> (stmt
);
8843 fndecl
= gimple_call_fndecl (call_stmt
);
8845 && fndecl_built_in_p (fndecl
, BUILT_IN_NORMAL
))
8846 switch (DECL_FUNCTION_CODE (fndecl
))
8848 case BUILT_IN_GOMP_BARRIER
:
8852 case BUILT_IN_GOMP_CANCEL
:
8853 case BUILT_IN_GOMP_CANCELLATION_POINT
:
8856 if (gimple_code (cctx
->stmt
) == GIMPLE_OMP_SECTION
)
8858 gcc_assert (gimple_call_lhs (call_stmt
) == NULL_TREE
);
8859 if (!cctx
->cancellable
)
8861 if (DECL_FUNCTION_CODE (fndecl
)
8862 == BUILT_IN_GOMP_CANCELLATION_POINT
)
8864 stmt
= gimple_build_nop ();
8865 gsi_replace (gsi_p
, stmt
, false);
8869 if (DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_GOMP_BARRIER
)
8871 fndecl
= builtin_decl_explicit (BUILT_IN_GOMP_BARRIER_CANCEL
);
8872 gimple_call_set_fndecl (call_stmt
, fndecl
);
8873 gimple_call_set_fntype (call_stmt
, TREE_TYPE (fndecl
));
8876 lhs
= create_tmp_var (TREE_TYPE (TREE_TYPE (fndecl
)));
8877 gimple_call_set_lhs (call_stmt
, lhs
);
8878 tree fallthru_label
;
8879 fallthru_label
= create_artificial_label (UNKNOWN_LOCATION
);
8881 g
= gimple_build_label (fallthru_label
);
8882 gsi_insert_after (gsi_p
, g
, GSI_SAME_STMT
);
8883 g
= gimple_build_cond (NE_EXPR
, lhs
,
8884 fold_convert (TREE_TYPE (lhs
),
8885 boolean_false_node
),
8886 cctx
->cancel_label
, fallthru_label
);
8887 gsi_insert_after (gsi_p
, g
, GSI_SAME_STMT
);
8894 if ((ctx
|| task_shared_vars
)
8895 && walk_gimple_op (stmt
, lower_omp_regimplify_p
,
8898 /* Just remove clobbers, this should happen only if we have
8899 "privatized" local addressable variables in SIMD regions,
8900 the clobber isn't needed in that case and gimplifying address
8901 of the ARRAY_REF into a pointer and creating MEM_REF based
8902 clobber would create worse code than we get with the clobber
8904 if (gimple_clobber_p (stmt
))
8906 gsi_replace (gsi_p
, gimple_build_nop (), true);
8909 lower_omp_regimplify_operands (ctx
, stmt
, gsi_p
);
8916 lower_omp (gimple_seq
*body
, omp_context
*ctx
)
8918 location_t saved_location
= input_location
;
8919 gimple_stmt_iterator gsi
;
8920 for (gsi
= gsi_start (*body
); !gsi_end_p (gsi
); gsi_next (&gsi
))
8921 lower_omp_1 (&gsi
, ctx
);
8922 /* During gimplification, we haven't folded statments inside offloading
8923 or taskreg regions (gimplify.c:maybe_fold_stmt); do that now. */
8924 if (target_nesting_level
|| taskreg_nesting_level
)
8925 for (gsi
= gsi_start (*body
); !gsi_end_p (gsi
); gsi_next (&gsi
))
8927 input_location
= saved_location
;
8930 /* Main entry point. */
8933 execute_lower_omp (void)
8939 /* This pass always runs, to provide PROP_gimple_lomp.
8940 But often, there is nothing to do. */
8941 if (flag_openacc
== 0 && flag_openmp
== 0
8942 && flag_openmp_simd
== 0)
8945 all_contexts
= splay_tree_new (splay_tree_compare_pointers
, 0,
8946 delete_omp_context
);
8948 body
= gimple_body (current_function_decl
);
8950 if (hsa_gen_requested_p ())
8951 omp_grid_gridify_all_targets (&body
);
8953 scan_omp (&body
, NULL
);
8954 gcc_assert (taskreg_nesting_level
== 0);
8955 FOR_EACH_VEC_ELT (taskreg_contexts
, i
, ctx
)
8956 finish_taskreg_scan (ctx
);
8957 taskreg_contexts
.release ();
8959 if (all_contexts
->root
)
8961 if (task_shared_vars
)
8962 push_gimplify_context ();
8963 lower_omp (&body
, NULL
);
8964 if (task_shared_vars
)
8965 pop_gimplify_context (NULL
);
8970 splay_tree_delete (all_contexts
);
8971 all_contexts
= NULL
;
8973 BITMAP_FREE (task_shared_vars
);
8975 /* If current function is a method, remove artificial dummy VAR_DECL created
8976 for non-static data member privatization, they aren't needed for
8977 debuginfo nor anything else, have been already replaced everywhere in the
8978 IL and cause problems with LTO. */
8979 if (DECL_ARGUMENTS (current_function_decl
)
8980 && DECL_ARTIFICIAL (DECL_ARGUMENTS (current_function_decl
))
8981 && (TREE_CODE (TREE_TYPE (DECL_ARGUMENTS (current_function_decl
)))
8983 remove_member_access_dummy_vars (DECL_INITIAL (current_function_decl
));
8989 const pass_data pass_data_lower_omp
=
8991 GIMPLE_PASS
, /* type */
8992 "omplower", /* name */
8993 OPTGROUP_OMP
, /* optinfo_flags */
8994 TV_NONE
, /* tv_id */
8995 PROP_gimple_any
, /* properties_required */
8996 PROP_gimple_lomp
| PROP_gimple_lomp_dev
, /* properties_provided */
8997 0, /* properties_destroyed */
8998 0, /* todo_flags_start */
8999 0, /* todo_flags_finish */
9002 class pass_lower_omp
: public gimple_opt_pass
9005 pass_lower_omp (gcc::context
*ctxt
)
9006 : gimple_opt_pass (pass_data_lower_omp
, ctxt
)
9009 /* opt_pass methods: */
9010 virtual unsigned int execute (function
*) { return execute_lower_omp (); }
9012 }; // class pass_lower_omp
9017 make_pass_lower_omp (gcc::context
*ctxt
)
9019 return new pass_lower_omp (ctxt
);
9022 /* The following is a utility to diagnose structured block violations.
9023 It is not part of the "omplower" pass, as that's invoked too late. It
9024 should be invoked by the respective front ends after gimplification. */
9026 static splay_tree all_labels
;
9028 /* Check for mismatched contexts and generate an error if needed. Return
9029 true if an error is detected. */
9032 diagnose_sb_0 (gimple_stmt_iterator
*gsi_p
,
9033 gimple
*branch_ctx
, gimple
*label_ctx
)
9035 gcc_checking_assert (!branch_ctx
|| is_gimple_omp (branch_ctx
));
9036 gcc_checking_assert (!label_ctx
|| is_gimple_omp (label_ctx
));
9038 if (label_ctx
== branch_ctx
)
9041 const char* kind
= NULL
;
9045 if ((branch_ctx
&& is_gimple_omp_oacc (branch_ctx
))
9046 || (label_ctx
&& is_gimple_omp_oacc (label_ctx
)))
9048 gcc_checking_assert (kind
== NULL
);
9054 gcc_checking_assert (flag_openmp
|| flag_openmp_simd
);
9058 /* Previously we kept track of the label's entire context in diagnose_sb_[12]
9059 so we could traverse it and issue a correct "exit" or "enter" error
9060 message upon a structured block violation.
9062 We built the context by building a list with tree_cons'ing, but there is
9063 no easy counterpart in gimple tuples. It seems like far too much work
9064 for issuing exit/enter error messages. If someone really misses the
9065 distinct error message... patches welcome. */
9068 /* Try to avoid confusing the user by producing and error message
9069 with correct "exit" or "enter" verbiage. We prefer "exit"
9070 unless we can show that LABEL_CTX is nested within BRANCH_CTX. */
9071 if (branch_ctx
== NULL
)
9077 if (TREE_VALUE (label_ctx
) == branch_ctx
)
9082 label_ctx
= TREE_CHAIN (label_ctx
);
9087 error ("invalid exit from %s structured block", kind
);
9089 error ("invalid entry to %s structured block", kind
);
9092 /* If it's obvious we have an invalid entry, be specific about the error. */
9093 if (branch_ctx
== NULL
)
9094 error ("invalid entry to %s structured block", kind
);
9097 /* Otherwise, be vague and lazy, but efficient. */
9098 error ("invalid branch to/from %s structured block", kind
);
9101 gsi_replace (gsi_p
, gimple_build_nop (), false);
9105 /* Pass 1: Create a minimal tree of structured blocks, and record
9106 where each label is found. */
9109 diagnose_sb_1 (gimple_stmt_iterator
*gsi_p
, bool *handled_ops_p
,
9110 struct walk_stmt_info
*wi
)
9112 gimple
*context
= (gimple
*) wi
->info
;
9113 gimple
*inner_context
;
9114 gimple
*stmt
= gsi_stmt (*gsi_p
);
9116 *handled_ops_p
= true;
9118 switch (gimple_code (stmt
))
9122 case GIMPLE_OMP_PARALLEL
:
9123 case GIMPLE_OMP_TASK
:
9124 case GIMPLE_OMP_SECTIONS
:
9125 case GIMPLE_OMP_SINGLE
:
9126 case GIMPLE_OMP_SECTION
:
9127 case GIMPLE_OMP_MASTER
:
9128 case GIMPLE_OMP_ORDERED
:
9129 case GIMPLE_OMP_CRITICAL
:
9130 case GIMPLE_OMP_TARGET
:
9131 case GIMPLE_OMP_TEAMS
:
9132 case GIMPLE_OMP_TASKGROUP
:
9133 /* The minimal context here is just the current OMP construct. */
9134 inner_context
= stmt
;
9135 wi
->info
= inner_context
;
9136 walk_gimple_seq (gimple_omp_body (stmt
), diagnose_sb_1
, NULL
, wi
);
9140 case GIMPLE_OMP_FOR
:
9141 inner_context
= stmt
;
9142 wi
->info
= inner_context
;
9143 /* gimple_omp_for_{index,initial,final} are all DECLs; no need to
9145 walk_gimple_seq (gimple_omp_for_pre_body (stmt
),
9146 diagnose_sb_1
, NULL
, wi
);
9147 walk_gimple_seq (gimple_omp_body (stmt
), diagnose_sb_1
, NULL
, wi
);
9152 splay_tree_insert (all_labels
,
9153 (splay_tree_key
) gimple_label_label (
9154 as_a
<glabel
*> (stmt
)),
9155 (splay_tree_value
) context
);
9165 /* Pass 2: Check each branch and see if its context differs from that of
9166 the destination label's context. */
9169 diagnose_sb_2 (gimple_stmt_iterator
*gsi_p
, bool *handled_ops_p
,
9170 struct walk_stmt_info
*wi
)
9172 gimple
*context
= (gimple
*) wi
->info
;
9174 gimple
*stmt
= gsi_stmt (*gsi_p
);
9176 *handled_ops_p
= true;
9178 switch (gimple_code (stmt
))
9182 case GIMPLE_OMP_PARALLEL
:
9183 case GIMPLE_OMP_TASK
:
9184 case GIMPLE_OMP_SECTIONS
:
9185 case GIMPLE_OMP_SINGLE
:
9186 case GIMPLE_OMP_SECTION
:
9187 case GIMPLE_OMP_MASTER
:
9188 case GIMPLE_OMP_ORDERED
:
9189 case GIMPLE_OMP_CRITICAL
:
9190 case GIMPLE_OMP_TARGET
:
9191 case GIMPLE_OMP_TEAMS
:
9192 case GIMPLE_OMP_TASKGROUP
:
9194 walk_gimple_seq_mod (gimple_omp_body_ptr (stmt
), diagnose_sb_2
, NULL
, wi
);
9198 case GIMPLE_OMP_FOR
:
9200 /* gimple_omp_for_{index,initial,final} are all DECLs; no need to
9202 walk_gimple_seq_mod (gimple_omp_for_pre_body_ptr (stmt
),
9203 diagnose_sb_2
, NULL
, wi
);
9204 walk_gimple_seq_mod (gimple_omp_body_ptr (stmt
), diagnose_sb_2
, NULL
, wi
);
9210 gcond
*cond_stmt
= as_a
<gcond
*> (stmt
);
9211 tree lab
= gimple_cond_true_label (cond_stmt
);
9214 n
= splay_tree_lookup (all_labels
,
9215 (splay_tree_key
) lab
);
9216 diagnose_sb_0 (gsi_p
, context
,
9217 n
? (gimple
*) n
->value
: NULL
);
9219 lab
= gimple_cond_false_label (cond_stmt
);
9222 n
= splay_tree_lookup (all_labels
,
9223 (splay_tree_key
) lab
);
9224 diagnose_sb_0 (gsi_p
, context
,
9225 n
? (gimple
*) n
->value
: NULL
);
9232 tree lab
= gimple_goto_dest (stmt
);
9233 if (TREE_CODE (lab
) != LABEL_DECL
)
9236 n
= splay_tree_lookup (all_labels
, (splay_tree_key
) lab
);
9237 diagnose_sb_0 (gsi_p
, context
, n
? (gimple
*) n
->value
: NULL
);
9243 gswitch
*switch_stmt
= as_a
<gswitch
*> (stmt
);
9245 for (i
= 0; i
< gimple_switch_num_labels (switch_stmt
); ++i
)
9247 tree lab
= CASE_LABEL (gimple_switch_label (switch_stmt
, i
));
9248 n
= splay_tree_lookup (all_labels
, (splay_tree_key
) lab
);
9249 if (n
&& diagnose_sb_0 (gsi_p
, context
, (gimple
*) n
->value
))
9256 diagnose_sb_0 (gsi_p
, context
, NULL
);
9267 diagnose_omp_structured_block_errors (void)
9269 struct walk_stmt_info wi
;
9270 gimple_seq body
= gimple_body (current_function_decl
);
9272 all_labels
= splay_tree_new (splay_tree_compare_pointers
, 0, 0);
9274 memset (&wi
, 0, sizeof (wi
));
9275 walk_gimple_seq (body
, diagnose_sb_1
, NULL
, &wi
);
9277 memset (&wi
, 0, sizeof (wi
));
9278 wi
.want_locations
= true;
9279 walk_gimple_seq_mod (&body
, diagnose_sb_2
, NULL
, &wi
);
9281 gimple_set_body (current_function_decl
, body
);
9283 splay_tree_delete (all_labels
);
9291 const pass_data pass_data_diagnose_omp_blocks
=
9293 GIMPLE_PASS
, /* type */
9294 "*diagnose_omp_blocks", /* name */
9295 OPTGROUP_OMP
, /* optinfo_flags */
9296 TV_NONE
, /* tv_id */
9297 PROP_gimple_any
, /* properties_required */
9298 0, /* properties_provided */
9299 0, /* properties_destroyed */
9300 0, /* todo_flags_start */
9301 0, /* todo_flags_finish */
9304 class pass_diagnose_omp_blocks
: public gimple_opt_pass
9307 pass_diagnose_omp_blocks (gcc::context
*ctxt
)
9308 : gimple_opt_pass (pass_data_diagnose_omp_blocks
, ctxt
)
9311 /* opt_pass methods: */
9312 virtual bool gate (function
*)
9314 return flag_openacc
|| flag_openmp
|| flag_openmp_simd
;
9316 virtual unsigned int execute (function
*)
9318 return diagnose_omp_structured_block_errors ();
9321 }; // class pass_diagnose_omp_blocks
9326 make_pass_diagnose_omp_blocks (gcc::context
*ctxt
)
9328 return new pass_diagnose_omp_blocks (ctxt
);
9332 #include "gt-omp-low.h"