1 /* Lowering pass for OpenMP directives. Converts OpenMP directives
2 into explicit calls to the runtime library (libgomp) and data
3 marshalling to implement data sharing and copying clauses.
4 Contributed by Diego Novillo <dnovillo@redhat.com>
6 Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012
7 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-iterator.h"
33 #include "tree-inline.h"
34 #include "langhooks.h"
35 #include "diagnostic-core.h"
36 #include "tree-flow.h"
40 #include "tree-pass.h"
43 #include "splay-tree.h"
48 /* Lowering of OpenMP parallel and workshare constructs proceeds in two
49 phases. The first phase scans the function looking for OMP statements
50 and then for variables that must be replaced to satisfy data sharing
51 clauses. The second phase expands code for the constructs, as well as
52 re-gimplifying things when variables have been replaced with complex
55 Final code generation is done by pass_expand_omp. The flowgraph is
56 scanned for parallel regions which are then moved to a new
57 function, to be invoked by the thread library. */
59 /* Context structure. Used to store information about each parallel
60 directive in the code. */
62 typedef struct omp_context
64 /* This field must be at the beginning, as we do "inheritance": Some
65 callback functions for tree-inline.c (e.g., omp_copy_decl)
66 receive a copy_body_data pointer that is up-casted to an
67 omp_context pointer. */
70 /* The tree of contexts corresponding to the encountered constructs. */
71 struct omp_context
*outer
;
74 /* Map variables to fields in a structure that allows communication
75 between sending and receiving threads. */
81 /* These are used just by task contexts, if task firstprivate fn is
82 needed. srecord_type is used to communicate from the thread
83 that encountered the task construct to task firstprivate fn,
84 record_type is allocated by GOMP_task, initialized by task firstprivate
85 fn and passed to the task body fn. */
86 splay_tree sfield_map
;
89 /* A chain of variables to add to the top-level block surrounding the
90 construct. In the case of a parallel, this is in the child function. */
93 /* What to do with variables with implicitly determined sharing
95 enum omp_clause_default_kind default_kind
;
97 /* Nesting depth of this context. Used to beautify error messages re
98 invalid gotos. The outermost ctx is depth 1, with depth 0 being
99 reserved for the main body of the function. */
102 /* True if this parallel directive is nested within another. */
107 struct omp_for_data_loop
109 tree v
, n1
, n2
, step
;
110 enum tree_code cond_code
;
113 /* A structure describing the main elements of a parallel loop. */
117 struct omp_for_data_loop loop
;
122 bool have_nowait
, have_ordered
;
123 enum omp_clause_schedule_kind sched_kind
;
124 struct omp_for_data_loop
*loops
;
128 static splay_tree all_contexts
;
129 static int taskreg_nesting_level
;
130 struct omp_region
*root_omp_region
;
131 static bitmap task_shared_vars
;
133 static void scan_omp (gimple_seq
*, omp_context
*);
134 static tree
scan_omp_1_op (tree
*, int *, void *);
136 #define WALK_SUBSTMTS \
140 case GIMPLE_EH_FILTER: \
141 case GIMPLE_TRANSACTION: \
142 /* The sub-statements for these should be walked. */ \
143 *handled_ops_p = false; \
146 /* Convenience function for calling scan_omp_1_op on tree operands. */
149 scan_omp_op (tree
*tp
, omp_context
*ctx
)
151 struct walk_stmt_info wi
;
153 memset (&wi
, 0, sizeof (wi
));
155 wi
.want_locations
= true;
157 return walk_tree (tp
, scan_omp_1_op
, &wi
, NULL
);
160 static void lower_omp (gimple_seq
*, omp_context
*);
161 static tree
lookup_decl_in_outer_ctx (tree
, omp_context
*);
162 static tree
maybe_lookup_decl_in_outer_ctx (tree
, omp_context
*);
164 /* Find an OpenMP clause of type KIND within CLAUSES. */
167 find_omp_clause (tree clauses
, enum omp_clause_code kind
)
169 for (; clauses
; clauses
= OMP_CLAUSE_CHAIN (clauses
))
170 if (OMP_CLAUSE_CODE (clauses
) == kind
)
176 /* Return true if CTX is for an omp parallel. */
179 is_parallel_ctx (omp_context
*ctx
)
181 return gimple_code (ctx
->stmt
) == GIMPLE_OMP_PARALLEL
;
185 /* Return true if CTX is for an omp task. */
188 is_task_ctx (omp_context
*ctx
)
190 return gimple_code (ctx
->stmt
) == GIMPLE_OMP_TASK
;
194 /* Return true if CTX is for an omp parallel or omp task. */
197 is_taskreg_ctx (omp_context
*ctx
)
199 return gimple_code (ctx
->stmt
) == GIMPLE_OMP_PARALLEL
200 || gimple_code (ctx
->stmt
) == GIMPLE_OMP_TASK
;
204 /* Return true if REGION is a combined parallel+workshare region. */
207 is_combined_parallel (struct omp_region
*region
)
209 return region
->is_combined_parallel
;
213 /* Extract the header elements of parallel loop FOR_STMT and store
217 extract_omp_for_data (gimple for_stmt
, struct omp_for_data
*fd
,
218 struct omp_for_data_loop
*loops
)
220 tree t
, var
, *collapse_iter
, *collapse_count
;
221 tree count
= NULL_TREE
, iter_type
= long_integer_type_node
;
222 struct omp_for_data_loop
*loop
;
224 struct omp_for_data_loop dummy_loop
;
225 location_t loc
= gimple_location (for_stmt
);
227 fd
->for_stmt
= for_stmt
;
229 fd
->collapse
= gimple_omp_for_collapse (for_stmt
);
230 if (fd
->collapse
> 1)
233 fd
->loops
= &fd
->loop
;
235 fd
->have_nowait
= fd
->have_ordered
= false;
236 fd
->sched_kind
= OMP_CLAUSE_SCHEDULE_STATIC
;
237 fd
->chunk_size
= NULL_TREE
;
238 collapse_iter
= NULL
;
239 collapse_count
= NULL
;
241 for (t
= gimple_omp_for_clauses (for_stmt
); t
; t
= OMP_CLAUSE_CHAIN (t
))
242 switch (OMP_CLAUSE_CODE (t
))
244 case OMP_CLAUSE_NOWAIT
:
245 fd
->have_nowait
= true;
247 case OMP_CLAUSE_ORDERED
:
248 fd
->have_ordered
= true;
250 case OMP_CLAUSE_SCHEDULE
:
251 fd
->sched_kind
= OMP_CLAUSE_SCHEDULE_KIND (t
);
252 fd
->chunk_size
= OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (t
);
254 case OMP_CLAUSE_COLLAPSE
:
255 if (fd
->collapse
> 1)
257 collapse_iter
= &OMP_CLAUSE_COLLAPSE_ITERVAR (t
);
258 collapse_count
= &OMP_CLAUSE_COLLAPSE_COUNT (t
);
264 /* FIXME: for now map schedule(auto) to schedule(static).
265 There should be analysis to determine whether all iterations
266 are approximately the same amount of work (then schedule(static)
267 is best) or if it varies (then schedule(dynamic,N) is better). */
268 if (fd
->sched_kind
== OMP_CLAUSE_SCHEDULE_AUTO
)
270 fd
->sched_kind
= OMP_CLAUSE_SCHEDULE_STATIC
;
271 gcc_assert (fd
->chunk_size
== NULL
);
273 gcc_assert (fd
->collapse
== 1 || collapse_iter
!= NULL
);
274 if (fd
->sched_kind
== OMP_CLAUSE_SCHEDULE_RUNTIME
)
275 gcc_assert (fd
->chunk_size
== NULL
);
276 else if (fd
->chunk_size
== NULL
)
278 /* We only need to compute a default chunk size for ordered
279 static loops and dynamic loops. */
280 if (fd
->sched_kind
!= OMP_CLAUSE_SCHEDULE_STATIC
283 fd
->chunk_size
= (fd
->sched_kind
== OMP_CLAUSE_SCHEDULE_STATIC
)
284 ? integer_zero_node
: integer_one_node
;
287 for (i
= 0; i
< fd
->collapse
; i
++)
289 if (fd
->collapse
== 1)
291 else if (loops
!= NULL
)
297 loop
->v
= gimple_omp_for_index (for_stmt
, i
);
298 gcc_assert (SSA_VAR_P (loop
->v
));
299 gcc_assert (TREE_CODE (TREE_TYPE (loop
->v
)) == INTEGER_TYPE
300 || TREE_CODE (TREE_TYPE (loop
->v
)) == POINTER_TYPE
);
301 var
= TREE_CODE (loop
->v
) == SSA_NAME
? SSA_NAME_VAR (loop
->v
) : loop
->v
;
302 loop
->n1
= gimple_omp_for_initial (for_stmt
, i
);
304 loop
->cond_code
= gimple_omp_for_cond (for_stmt
, i
);
305 loop
->n2
= gimple_omp_for_final (for_stmt
, i
);
306 switch (loop
->cond_code
)
312 if (POINTER_TYPE_P (TREE_TYPE (loop
->n2
)))
313 loop
->n2
= fold_build_pointer_plus_hwi_loc (loc
, loop
->n2
, 1);
315 loop
->n2
= fold_build2_loc (loc
,
316 PLUS_EXPR
, TREE_TYPE (loop
->n2
), loop
->n2
,
317 build_int_cst (TREE_TYPE (loop
->n2
), 1));
318 loop
->cond_code
= LT_EXPR
;
321 if (POINTER_TYPE_P (TREE_TYPE (loop
->n2
)))
322 loop
->n2
= fold_build_pointer_plus_hwi_loc (loc
, loop
->n2
, -1);
324 loop
->n2
= fold_build2_loc (loc
,
325 MINUS_EXPR
, TREE_TYPE (loop
->n2
), loop
->n2
,
326 build_int_cst (TREE_TYPE (loop
->n2
), 1));
327 loop
->cond_code
= GT_EXPR
;
333 t
= gimple_omp_for_incr (for_stmt
, i
);
334 gcc_assert (TREE_OPERAND (t
, 0) == var
);
335 switch (TREE_CODE (t
))
338 loop
->step
= TREE_OPERAND (t
, 1);
340 case POINTER_PLUS_EXPR
:
341 loop
->step
= fold_convert (ssizetype
, TREE_OPERAND (t
, 1));
344 loop
->step
= TREE_OPERAND (t
, 1);
345 loop
->step
= fold_build1_loc (loc
,
346 NEGATE_EXPR
, TREE_TYPE (loop
->step
),
353 if (iter_type
!= long_long_unsigned_type_node
)
355 if (POINTER_TYPE_P (TREE_TYPE (loop
->v
)))
356 iter_type
= long_long_unsigned_type_node
;
357 else if (TYPE_UNSIGNED (TREE_TYPE (loop
->v
))
358 && TYPE_PRECISION (TREE_TYPE (loop
->v
))
359 >= TYPE_PRECISION (iter_type
))
363 if (loop
->cond_code
== LT_EXPR
)
364 n
= fold_build2_loc (loc
,
365 PLUS_EXPR
, TREE_TYPE (loop
->v
),
366 loop
->n2
, loop
->step
);
369 if (TREE_CODE (n
) != INTEGER_CST
370 || tree_int_cst_lt (TYPE_MAX_VALUE (iter_type
), n
))
371 iter_type
= long_long_unsigned_type_node
;
373 else if (TYPE_PRECISION (TREE_TYPE (loop
->v
))
374 > TYPE_PRECISION (iter_type
))
378 if (loop
->cond_code
== LT_EXPR
)
381 n2
= fold_build2_loc (loc
,
382 PLUS_EXPR
, TREE_TYPE (loop
->v
),
383 loop
->n2
, loop
->step
);
387 n1
= fold_build2_loc (loc
,
388 MINUS_EXPR
, TREE_TYPE (loop
->v
),
389 loop
->n2
, loop
->step
);
392 if (TREE_CODE (n1
) != INTEGER_CST
393 || TREE_CODE (n2
) != INTEGER_CST
394 || !tree_int_cst_lt (TYPE_MIN_VALUE (iter_type
), n1
)
395 || !tree_int_cst_lt (n2
, TYPE_MAX_VALUE (iter_type
)))
396 iter_type
= long_long_unsigned_type_node
;
400 if (collapse_count
&& *collapse_count
== NULL
)
402 if ((i
== 0 || count
!= NULL_TREE
)
403 && TREE_CODE (TREE_TYPE (loop
->v
)) == INTEGER_TYPE
404 && TREE_CONSTANT (loop
->n1
)
405 && TREE_CONSTANT (loop
->n2
)
406 && TREE_CODE (loop
->step
) == INTEGER_CST
)
408 tree itype
= TREE_TYPE (loop
->v
);
410 if (POINTER_TYPE_P (itype
))
411 itype
= signed_type_for (itype
);
412 t
= build_int_cst (itype
, (loop
->cond_code
== LT_EXPR
? -1 : 1));
413 t
= fold_build2_loc (loc
,
415 fold_convert_loc (loc
, itype
, loop
->step
), t
);
416 t
= fold_build2_loc (loc
, PLUS_EXPR
, itype
, t
,
417 fold_convert_loc (loc
, itype
, loop
->n2
));
418 t
= fold_build2_loc (loc
, MINUS_EXPR
, itype
, t
,
419 fold_convert_loc (loc
, itype
, loop
->n1
));
420 if (TYPE_UNSIGNED (itype
) && loop
->cond_code
== GT_EXPR
)
421 t
= fold_build2_loc (loc
, TRUNC_DIV_EXPR
, itype
,
422 fold_build1_loc (loc
, NEGATE_EXPR
, itype
, t
),
423 fold_build1_loc (loc
, NEGATE_EXPR
, itype
,
424 fold_convert_loc (loc
, itype
,
427 t
= fold_build2_loc (loc
, TRUNC_DIV_EXPR
, itype
, t
,
428 fold_convert_loc (loc
, itype
, loop
->step
));
429 t
= fold_convert_loc (loc
, long_long_unsigned_type_node
, t
);
430 if (count
!= NULL_TREE
)
431 count
= fold_build2_loc (loc
,
432 MULT_EXPR
, long_long_unsigned_type_node
,
436 if (TREE_CODE (count
) != INTEGER_CST
)
446 if (!tree_int_cst_lt (count
, TYPE_MAX_VALUE (long_integer_type_node
)))
447 iter_type
= long_long_unsigned_type_node
;
449 iter_type
= long_integer_type_node
;
451 else if (collapse_iter
&& *collapse_iter
!= NULL
)
452 iter_type
= TREE_TYPE (*collapse_iter
);
453 fd
->iter_type
= iter_type
;
454 if (collapse_iter
&& *collapse_iter
== NULL
)
455 *collapse_iter
= create_tmp_var (iter_type
, ".iter");
456 if (collapse_count
&& *collapse_count
== NULL
)
459 *collapse_count
= fold_convert_loc (loc
, iter_type
, count
);
461 *collapse_count
= create_tmp_var (iter_type
, ".count");
464 if (fd
->collapse
> 1)
466 fd
->loop
.v
= *collapse_iter
;
467 fd
->loop
.n1
= build_int_cst (TREE_TYPE (fd
->loop
.v
), 0);
468 fd
->loop
.n2
= *collapse_count
;
469 fd
->loop
.step
= build_int_cst (TREE_TYPE (fd
->loop
.v
), 1);
470 fd
->loop
.cond_code
= LT_EXPR
;
475 /* Given two blocks PAR_ENTRY_BB and WS_ENTRY_BB such that WS_ENTRY_BB
476 is the immediate dominator of PAR_ENTRY_BB, return true if there
477 are no data dependencies that would prevent expanding the parallel
478 directive at PAR_ENTRY_BB as a combined parallel+workshare region.
480 When expanding a combined parallel+workshare region, the call to
481 the child function may need additional arguments in the case of
482 GIMPLE_OMP_FOR regions. In some cases, these arguments are
483 computed out of variables passed in from the parent to the child
484 via 'struct .omp_data_s'. For instance:
486 #pragma omp parallel for schedule (guided, i * 4)
491 # BLOCK 2 (PAR_ENTRY_BB)
493 #pragma omp parallel [child fn: bar.omp_fn.0 ( ..., D.1598)
495 # BLOCK 3 (WS_ENTRY_BB)
496 .omp_data_i = &.omp_data_o;
497 D.1667 = .omp_data_i->i;
499 #pragma omp for schedule (guided, D.1598)
501 When we outline the parallel region, the call to the child function
502 'bar.omp_fn.0' will need the value D.1598 in its argument list, but
503 that value is computed *after* the call site. So, in principle we
504 cannot do the transformation.
506 To see whether the code in WS_ENTRY_BB blocks the combined
507 parallel+workshare call, we collect all the variables used in the
508 GIMPLE_OMP_FOR header check whether they appear on the LHS of any
509 statement in WS_ENTRY_BB. If so, then we cannot emit the combined
512 FIXME. If we had the SSA form built at this point, we could merely
513 hoist the code in block 3 into block 2 and be done with it. But at
514 this point we don't have dataflow information and though we could
515 hack something up here, it is really not worth the aggravation. */
518 workshare_safe_to_combine_p (basic_block ws_entry_bb
)
520 struct omp_for_data fd
;
521 gimple ws_stmt
= last_stmt (ws_entry_bb
);
523 if (gimple_code (ws_stmt
) == GIMPLE_OMP_SECTIONS
)
526 gcc_assert (gimple_code (ws_stmt
) == GIMPLE_OMP_FOR
);
528 extract_omp_for_data (ws_stmt
, &fd
, NULL
);
530 if (fd
.collapse
> 1 && TREE_CODE (fd
.loop
.n2
) != INTEGER_CST
)
532 if (fd
.iter_type
!= long_integer_type_node
)
535 /* FIXME. We give up too easily here. If any of these arguments
536 are not constants, they will likely involve variables that have
537 been mapped into fields of .omp_data_s for sharing with the child
538 function. With appropriate data flow, it would be possible to
540 if (!is_gimple_min_invariant (fd
.loop
.n1
)
541 || !is_gimple_min_invariant (fd
.loop
.n2
)
542 || !is_gimple_min_invariant (fd
.loop
.step
)
543 || (fd
.chunk_size
&& !is_gimple_min_invariant (fd
.chunk_size
)))
550 /* Collect additional arguments needed to emit a combined
551 parallel+workshare call. WS_STMT is the workshare directive being
554 static VEC(tree
,gc
) *
555 get_ws_args_for (gimple ws_stmt
)
558 location_t loc
= gimple_location (ws_stmt
);
559 VEC(tree
,gc
) *ws_args
;
561 if (gimple_code (ws_stmt
) == GIMPLE_OMP_FOR
)
563 struct omp_for_data fd
;
565 extract_omp_for_data (ws_stmt
, &fd
, NULL
);
567 ws_args
= VEC_alloc (tree
, gc
, 3 + (fd
.chunk_size
!= 0));
569 t
= fold_convert_loc (loc
, long_integer_type_node
, fd
.loop
.n1
);
570 VEC_quick_push (tree
, ws_args
, t
);
572 t
= fold_convert_loc (loc
, long_integer_type_node
, fd
.loop
.n2
);
573 VEC_quick_push (tree
, ws_args
, t
);
575 t
= fold_convert_loc (loc
, long_integer_type_node
, fd
.loop
.step
);
576 VEC_quick_push (tree
, ws_args
, t
);
580 t
= fold_convert_loc (loc
, long_integer_type_node
, fd
.chunk_size
);
581 VEC_quick_push (tree
, ws_args
, t
);
586 else if (gimple_code (ws_stmt
) == GIMPLE_OMP_SECTIONS
)
588 /* Number of sections is equal to the number of edges from the
589 GIMPLE_OMP_SECTIONS_SWITCH statement, except for the one to
590 the exit of the sections region. */
591 basic_block bb
= single_succ (gimple_bb (ws_stmt
));
592 t
= build_int_cst (unsigned_type_node
, EDGE_COUNT (bb
->succs
) - 1);
593 ws_args
= VEC_alloc (tree
, gc
, 1);
594 VEC_quick_push (tree
, ws_args
, t
);
602 /* Discover whether REGION is a combined parallel+workshare region. */
605 determine_parallel_type (struct omp_region
*region
)
607 basic_block par_entry_bb
, par_exit_bb
;
608 basic_block ws_entry_bb
, ws_exit_bb
;
610 if (region
== NULL
|| region
->inner
== NULL
611 || region
->exit
== NULL
|| region
->inner
->exit
== NULL
612 || region
->inner
->cont
== NULL
)
615 /* We only support parallel+for and parallel+sections. */
616 if (region
->type
!= GIMPLE_OMP_PARALLEL
617 || (region
->inner
->type
!= GIMPLE_OMP_FOR
618 && region
->inner
->type
!= GIMPLE_OMP_SECTIONS
))
621 /* Check for perfect nesting PAR_ENTRY_BB -> WS_ENTRY_BB and
622 WS_EXIT_BB -> PAR_EXIT_BB. */
623 par_entry_bb
= region
->entry
;
624 par_exit_bb
= region
->exit
;
625 ws_entry_bb
= region
->inner
->entry
;
626 ws_exit_bb
= region
->inner
->exit
;
628 if (single_succ (par_entry_bb
) == ws_entry_bb
629 && single_succ (ws_exit_bb
) == par_exit_bb
630 && workshare_safe_to_combine_p (ws_entry_bb
)
631 && (gimple_omp_parallel_combined_p (last_stmt (par_entry_bb
))
632 || (last_and_only_stmt (ws_entry_bb
)
633 && last_and_only_stmt (par_exit_bb
))))
635 gimple ws_stmt
= last_stmt (ws_entry_bb
);
637 if (region
->inner
->type
== GIMPLE_OMP_FOR
)
639 /* If this is a combined parallel loop, we need to determine
640 whether or not to use the combined library calls. There
641 are two cases where we do not apply the transformation:
642 static loops and any kind of ordered loop. In the first
643 case, we already open code the loop so there is no need
644 to do anything else. In the latter case, the combined
645 parallel loop call would still need extra synchronization
646 to implement ordered semantics, so there would not be any
647 gain in using the combined call. */
648 tree clauses
= gimple_omp_for_clauses (ws_stmt
);
649 tree c
= find_omp_clause (clauses
, OMP_CLAUSE_SCHEDULE
);
651 || OMP_CLAUSE_SCHEDULE_KIND (c
) == OMP_CLAUSE_SCHEDULE_STATIC
652 || find_omp_clause (clauses
, OMP_CLAUSE_ORDERED
))
654 region
->is_combined_parallel
= false;
655 region
->inner
->is_combined_parallel
= false;
660 region
->is_combined_parallel
= true;
661 region
->inner
->is_combined_parallel
= true;
662 region
->ws_args
= get_ws_args_for (ws_stmt
);
667 /* Return true if EXPR is variable sized. */
670 is_variable_sized (const_tree expr
)
672 return !TREE_CONSTANT (TYPE_SIZE_UNIT (TREE_TYPE (expr
)));
675 /* Return true if DECL is a reference type. */
678 is_reference (tree decl
)
680 return lang_hooks
.decls
.omp_privatize_by_reference (decl
);
683 /* Lookup variables in the decl or field splay trees. The "maybe" form
684 allows for the variable form to not have been entered, otherwise we
685 assert that the variable must have been entered. */
688 lookup_decl (tree var
, omp_context
*ctx
)
691 n
= (tree
*) pointer_map_contains (ctx
->cb
.decl_map
, var
);
696 maybe_lookup_decl (const_tree var
, omp_context
*ctx
)
699 n
= (tree
*) pointer_map_contains (ctx
->cb
.decl_map
, var
);
700 return n
? *n
: NULL_TREE
;
704 lookup_field (tree var
, omp_context
*ctx
)
707 n
= splay_tree_lookup (ctx
->field_map
, (splay_tree_key
) var
);
708 return (tree
) n
->value
;
712 lookup_sfield (tree var
, omp_context
*ctx
)
715 n
= splay_tree_lookup (ctx
->sfield_map
716 ? ctx
->sfield_map
: ctx
->field_map
,
717 (splay_tree_key
) var
);
718 return (tree
) n
->value
;
722 maybe_lookup_field (tree var
, omp_context
*ctx
)
725 n
= splay_tree_lookup (ctx
->field_map
, (splay_tree_key
) var
);
726 return n
? (tree
) n
->value
: NULL_TREE
;
729 /* Return true if DECL should be copied by pointer. SHARED_CTX is
730 the parallel context if DECL is to be shared. */
733 use_pointer_for_field (tree decl
, omp_context
*shared_ctx
)
735 if (AGGREGATE_TYPE_P (TREE_TYPE (decl
)))
738 /* We can only use copy-in/copy-out semantics for shared variables
739 when we know the value is not accessible from an outer scope. */
742 /* ??? Trivially accessible from anywhere. But why would we even
743 be passing an address in this case? Should we simply assert
744 this to be false, or should we have a cleanup pass that removes
745 these from the list of mappings? */
746 if (TREE_STATIC (decl
) || DECL_EXTERNAL (decl
))
749 /* For variables with DECL_HAS_VALUE_EXPR_P set, we cannot tell
750 without analyzing the expression whether or not its location
751 is accessible to anyone else. In the case of nested parallel
752 regions it certainly may be. */
753 if (TREE_CODE (decl
) != RESULT_DECL
&& DECL_HAS_VALUE_EXPR_P (decl
))
756 /* Do not use copy-in/copy-out for variables that have their
758 if (TREE_ADDRESSABLE (decl
))
761 /* Disallow copy-in/out in nested parallel if
762 decl is shared in outer parallel, otherwise
763 each thread could store the shared variable
764 in its own copy-in location, making the
765 variable no longer really shared. */
766 if (!TREE_READONLY (decl
) && shared_ctx
->is_nested
)
770 for (up
= shared_ctx
->outer
; up
; up
= up
->outer
)
771 if (is_taskreg_ctx (up
) && maybe_lookup_decl (decl
, up
))
778 for (c
= gimple_omp_taskreg_clauses (up
->stmt
);
779 c
; c
= OMP_CLAUSE_CHAIN (c
))
780 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_SHARED
781 && OMP_CLAUSE_DECL (c
) == decl
)
785 goto maybe_mark_addressable_and_ret
;
789 /* For tasks avoid using copy-in/out, unless they are readonly
790 (in which case just copy-in is used). As tasks can be
791 deferred or executed in different thread, when GOMP_task
792 returns, the task hasn't necessarily terminated. */
793 if (!TREE_READONLY (decl
) && is_task_ctx (shared_ctx
))
796 maybe_mark_addressable_and_ret
:
797 outer
= maybe_lookup_decl_in_outer_ctx (decl
, shared_ctx
);
798 if (is_gimple_reg (outer
))
800 /* Taking address of OUTER in lower_send_shared_vars
801 might need regimplification of everything that uses the
803 if (!task_shared_vars
)
804 task_shared_vars
= BITMAP_ALLOC (NULL
);
805 bitmap_set_bit (task_shared_vars
, DECL_UID (outer
));
806 TREE_ADDRESSABLE (outer
) = 1;
815 /* Create a new VAR_DECL and copy information from VAR to it. */
818 copy_var_decl (tree var
, tree name
, tree type
)
820 tree copy
= build_decl (DECL_SOURCE_LOCATION (var
), VAR_DECL
, name
, type
);
822 TREE_ADDRESSABLE (copy
) = TREE_ADDRESSABLE (var
);
823 TREE_THIS_VOLATILE (copy
) = TREE_THIS_VOLATILE (var
);
824 DECL_GIMPLE_REG_P (copy
) = DECL_GIMPLE_REG_P (var
);
825 DECL_ARTIFICIAL (copy
) = DECL_ARTIFICIAL (var
);
826 DECL_IGNORED_P (copy
) = DECL_IGNORED_P (var
);
827 DECL_CONTEXT (copy
) = DECL_CONTEXT (var
);
828 TREE_USED (copy
) = 1;
829 DECL_SEEN_IN_BIND_EXPR_P (copy
) = 1;
834 /* Construct a new automatic decl similar to VAR. */
837 omp_copy_decl_2 (tree var
, tree name
, tree type
, omp_context
*ctx
)
839 tree copy
= copy_var_decl (var
, name
, type
);
841 DECL_CONTEXT (copy
) = current_function_decl
;
842 DECL_CHAIN (copy
) = ctx
->block_vars
;
843 ctx
->block_vars
= copy
;
849 omp_copy_decl_1 (tree var
, omp_context
*ctx
)
851 return omp_copy_decl_2 (var
, DECL_NAME (var
), TREE_TYPE (var
), ctx
);
854 /* Build COMPONENT_REF and set TREE_THIS_VOLATILE and TREE_READONLY on it
857 omp_build_component_ref (tree obj
, tree field
)
859 tree ret
= build3 (COMPONENT_REF
, TREE_TYPE (field
), obj
, field
, NULL
);
860 if (TREE_THIS_VOLATILE (field
))
861 TREE_THIS_VOLATILE (ret
) |= 1;
862 if (TREE_READONLY (field
))
863 TREE_READONLY (ret
) |= 1;
867 /* Build tree nodes to access the field for VAR on the receiver side. */
870 build_receiver_ref (tree var
, bool by_ref
, omp_context
*ctx
)
872 tree x
, field
= lookup_field (var
, ctx
);
874 /* If the receiver record type was remapped in the child function,
875 remap the field into the new record type. */
876 x
= maybe_lookup_field (field
, ctx
);
880 x
= build_simple_mem_ref (ctx
->receiver_decl
);
881 x
= omp_build_component_ref (x
, field
);
883 x
= build_simple_mem_ref (x
);
888 /* Build tree nodes to access VAR in the scope outer to CTX. In the case
889 of a parallel, this is a component reference; for workshare constructs
890 this is some variable. */
893 build_outer_var_ref (tree var
, omp_context
*ctx
)
897 if (is_global_var (maybe_lookup_decl_in_outer_ctx (var
, ctx
)))
899 else if (is_variable_sized (var
))
901 x
= TREE_OPERAND (DECL_VALUE_EXPR (var
), 0);
902 x
= build_outer_var_ref (x
, ctx
);
903 x
= build_simple_mem_ref (x
);
905 else if (is_taskreg_ctx (ctx
))
907 bool by_ref
= use_pointer_for_field (var
, NULL
);
908 x
= build_receiver_ref (var
, by_ref
, ctx
);
911 x
= lookup_decl (var
, ctx
->outer
);
912 else if (is_reference (var
))
913 /* This can happen with orphaned constructs. If var is reference, it is
914 possible it is shared and as such valid. */
919 if (is_reference (var
))
920 x
= build_simple_mem_ref (x
);
925 /* Build tree nodes to access the field for VAR on the sender side. */
928 build_sender_ref (tree var
, omp_context
*ctx
)
930 tree field
= lookup_sfield (var
, ctx
);
931 return omp_build_component_ref (ctx
->sender_decl
, field
);
934 /* Add a new field for VAR inside the structure CTX->SENDER_DECL. */
937 install_var_field (tree var
, bool by_ref
, int mask
, omp_context
*ctx
)
939 tree field
, type
, sfield
= NULL_TREE
;
941 gcc_assert ((mask
& 1) == 0
942 || !splay_tree_lookup (ctx
->field_map
, (splay_tree_key
) var
));
943 gcc_assert ((mask
& 2) == 0 || !ctx
->sfield_map
944 || !splay_tree_lookup (ctx
->sfield_map
, (splay_tree_key
) var
));
946 type
= TREE_TYPE (var
);
948 type
= build_pointer_type (type
);
949 else if ((mask
& 3) == 1 && is_reference (var
))
950 type
= TREE_TYPE (type
);
952 field
= build_decl (DECL_SOURCE_LOCATION (var
),
953 FIELD_DECL
, DECL_NAME (var
), type
);
955 /* Remember what variable this field was created for. This does have a
956 side effect of making dwarf2out ignore this member, so for helpful
957 debugging we clear it later in delete_omp_context. */
958 DECL_ABSTRACT_ORIGIN (field
) = var
;
959 if (type
== TREE_TYPE (var
))
961 DECL_ALIGN (field
) = DECL_ALIGN (var
);
962 DECL_USER_ALIGN (field
) = DECL_USER_ALIGN (var
);
963 TREE_THIS_VOLATILE (field
) = TREE_THIS_VOLATILE (var
);
966 DECL_ALIGN (field
) = TYPE_ALIGN (type
);
970 insert_field_into_struct (ctx
->record_type
, field
);
971 if (ctx
->srecord_type
)
973 sfield
= build_decl (DECL_SOURCE_LOCATION (var
),
974 FIELD_DECL
, DECL_NAME (var
), type
);
975 DECL_ABSTRACT_ORIGIN (sfield
) = var
;
976 DECL_ALIGN (sfield
) = DECL_ALIGN (field
);
977 DECL_USER_ALIGN (sfield
) = DECL_USER_ALIGN (field
);
978 TREE_THIS_VOLATILE (sfield
) = TREE_THIS_VOLATILE (field
);
979 insert_field_into_struct (ctx
->srecord_type
, sfield
);
984 if (ctx
->srecord_type
== NULL_TREE
)
988 ctx
->srecord_type
= lang_hooks
.types
.make_type (RECORD_TYPE
);
989 ctx
->sfield_map
= splay_tree_new (splay_tree_compare_pointers
, 0, 0);
990 for (t
= TYPE_FIELDS (ctx
->record_type
); t
; t
= TREE_CHAIN (t
))
992 sfield
= build_decl (DECL_SOURCE_LOCATION (var
),
993 FIELD_DECL
, DECL_NAME (t
), TREE_TYPE (t
));
994 DECL_ABSTRACT_ORIGIN (sfield
) = DECL_ABSTRACT_ORIGIN (t
);
995 insert_field_into_struct (ctx
->srecord_type
, sfield
);
996 splay_tree_insert (ctx
->sfield_map
,
997 (splay_tree_key
) DECL_ABSTRACT_ORIGIN (t
),
998 (splay_tree_value
) sfield
);
1002 insert_field_into_struct ((mask
& 1) ? ctx
->record_type
1003 : ctx
->srecord_type
, field
);
1007 splay_tree_insert (ctx
->field_map
, (splay_tree_key
) var
,
1008 (splay_tree_value
) field
);
1009 if ((mask
& 2) && ctx
->sfield_map
)
1010 splay_tree_insert (ctx
->sfield_map
, (splay_tree_key
) var
,
1011 (splay_tree_value
) sfield
);
1015 install_var_local (tree var
, omp_context
*ctx
)
1017 tree new_var
= omp_copy_decl_1 (var
, ctx
);
1018 insert_decl_map (&ctx
->cb
, var
, new_var
);
1022 /* Adjust the replacement for DECL in CTX for the new context. This means
1023 copying the DECL_VALUE_EXPR, and fixing up the type. */
1026 fixup_remapped_decl (tree decl
, omp_context
*ctx
, bool private_debug
)
1028 tree new_decl
, size
;
1030 new_decl
= lookup_decl (decl
, ctx
);
1032 TREE_TYPE (new_decl
) = remap_type (TREE_TYPE (decl
), &ctx
->cb
);
1034 if ((!TREE_CONSTANT (DECL_SIZE (new_decl
)) || private_debug
)
1035 && DECL_HAS_VALUE_EXPR_P (decl
))
1037 tree ve
= DECL_VALUE_EXPR (decl
);
1038 walk_tree (&ve
, copy_tree_body_r
, &ctx
->cb
, NULL
);
1039 SET_DECL_VALUE_EXPR (new_decl
, ve
);
1040 DECL_HAS_VALUE_EXPR_P (new_decl
) = 1;
1043 if (!TREE_CONSTANT (DECL_SIZE (new_decl
)))
1045 size
= remap_decl (DECL_SIZE (decl
), &ctx
->cb
);
1046 if (size
== error_mark_node
)
1047 size
= TYPE_SIZE (TREE_TYPE (new_decl
));
1048 DECL_SIZE (new_decl
) = size
;
1050 size
= remap_decl (DECL_SIZE_UNIT (decl
), &ctx
->cb
);
1051 if (size
== error_mark_node
)
1052 size
= TYPE_SIZE_UNIT (TREE_TYPE (new_decl
));
1053 DECL_SIZE_UNIT (new_decl
) = size
;
1057 /* The callback for remap_decl. Search all containing contexts for a
1058 mapping of the variable; this avoids having to duplicate the splay
1059 tree ahead of time. We know a mapping doesn't already exist in the
1060 given context. Create new mappings to implement default semantics. */
1063 omp_copy_decl (tree var
, copy_body_data
*cb
)
1065 omp_context
*ctx
= (omp_context
*) cb
;
1068 if (TREE_CODE (var
) == LABEL_DECL
)
1070 new_var
= create_artificial_label (DECL_SOURCE_LOCATION (var
));
1071 DECL_CONTEXT (new_var
) = current_function_decl
;
1072 insert_decl_map (&ctx
->cb
, var
, new_var
);
1076 while (!is_taskreg_ctx (ctx
))
1081 new_var
= maybe_lookup_decl (var
, ctx
);
1086 if (is_global_var (var
) || decl_function_context (var
) != ctx
->cb
.src_fn
)
1089 return error_mark_node
;
1093 /* Return the parallel region associated with STMT. */
1095 /* Debugging dumps for parallel regions. */
1096 void dump_omp_region (FILE *, struct omp_region
*, int);
1097 void debug_omp_region (struct omp_region
*);
1098 void debug_all_omp_regions (void);
1100 /* Dump the parallel region tree rooted at REGION. */
1103 dump_omp_region (FILE *file
, struct omp_region
*region
, int indent
)
1105 fprintf (file
, "%*sbb %d: %s\n", indent
, "", region
->entry
->index
,
1106 gimple_code_name
[region
->type
]);
1109 dump_omp_region (file
, region
->inner
, indent
+ 4);
1113 fprintf (file
, "%*sbb %d: GIMPLE_OMP_CONTINUE\n", indent
, "",
1114 region
->cont
->index
);
1118 fprintf (file
, "%*sbb %d: GIMPLE_OMP_RETURN\n", indent
, "",
1119 region
->exit
->index
);
1121 fprintf (file
, "%*s[no exit marker]\n", indent
, "");
1124 dump_omp_region (file
, region
->next
, indent
);
1128 debug_omp_region (struct omp_region
*region
)
1130 dump_omp_region (stderr
, region
, 0);
1134 debug_all_omp_regions (void)
1136 dump_omp_region (stderr
, root_omp_region
, 0);
1140 /* Create a new parallel region starting at STMT inside region PARENT. */
1143 new_omp_region (basic_block bb
, enum gimple_code type
,
1144 struct omp_region
*parent
)
1146 struct omp_region
*region
= XCNEW (struct omp_region
);
1148 region
->outer
= parent
;
1150 region
->type
= type
;
1154 /* This is a nested region. Add it to the list of inner
1155 regions in PARENT. */
1156 region
->next
= parent
->inner
;
1157 parent
->inner
= region
;
1161 /* This is a toplevel region. Add it to the list of toplevel
1162 regions in ROOT_OMP_REGION. */
1163 region
->next
= root_omp_region
;
1164 root_omp_region
= region
;
1170 /* Release the memory associated with the region tree rooted at REGION. */
1173 free_omp_region_1 (struct omp_region
*region
)
1175 struct omp_region
*i
, *n
;
1177 for (i
= region
->inner
; i
; i
= n
)
1180 free_omp_region_1 (i
);
1186 /* Release the memory for the entire omp region tree. */
1189 free_omp_regions (void)
1191 struct omp_region
*r
, *n
;
1192 for (r
= root_omp_region
; r
; r
= n
)
1195 free_omp_region_1 (r
);
1197 root_omp_region
= NULL
;
1201 /* Create a new context, with OUTER_CTX being the surrounding context. */
1203 static omp_context
*
1204 new_omp_context (gimple stmt
, omp_context
*outer_ctx
)
1206 omp_context
*ctx
= XCNEW (omp_context
);
1208 splay_tree_insert (all_contexts
, (splay_tree_key
) stmt
,
1209 (splay_tree_value
) ctx
);
1214 ctx
->outer
= outer_ctx
;
1215 ctx
->cb
= outer_ctx
->cb
;
1216 ctx
->cb
.block
= NULL
;
1217 ctx
->depth
= outer_ctx
->depth
+ 1;
1221 ctx
->cb
.src_fn
= current_function_decl
;
1222 ctx
->cb
.dst_fn
= current_function_decl
;
1223 ctx
->cb
.src_node
= cgraph_get_node (current_function_decl
);
1224 gcc_checking_assert (ctx
->cb
.src_node
);
1225 ctx
->cb
.dst_node
= ctx
->cb
.src_node
;
1226 ctx
->cb
.src_cfun
= cfun
;
1227 ctx
->cb
.copy_decl
= omp_copy_decl
;
1228 ctx
->cb
.eh_lp_nr
= 0;
1229 ctx
->cb
.transform_call_graph_edges
= CB_CGE_MOVE
;
1233 ctx
->cb
.decl_map
= pointer_map_create ();
1238 static gimple_seq
maybe_catch_exception (gimple_seq
);
1240 /* Finalize task copyfn. */
1243 finalize_task_copyfn (gimple task_stmt
)
1245 struct function
*child_cfun
;
1246 tree child_fn
, old_fn
;
1247 gimple_seq seq
= NULL
, new_seq
;
1250 child_fn
= gimple_omp_task_copy_fn (task_stmt
);
1251 if (child_fn
== NULL_TREE
)
1254 child_cfun
= DECL_STRUCT_FUNCTION (child_fn
);
1256 /* Inform the callgraph about the new function. */
1257 DECL_STRUCT_FUNCTION (child_fn
)->curr_properties
1258 = cfun
->curr_properties
& ~PROP_loops
;
1260 old_fn
= current_function_decl
;
1261 push_cfun (child_cfun
);
1262 current_function_decl
= child_fn
;
1263 bind
= gimplify_body (child_fn
, false);
1264 gimple_seq_add_stmt (&seq
, bind
);
1265 new_seq
= maybe_catch_exception (seq
);
1268 bind
= gimple_build_bind (NULL
, new_seq
, NULL
);
1270 gimple_seq_add_stmt (&seq
, bind
);
1272 gimple_set_body (child_fn
, seq
);
1274 current_function_decl
= old_fn
;
1276 cgraph_add_new_function (child_fn
, false);
1279 /* Destroy a omp_context data structures. Called through the splay tree
1280 value delete callback. */
1283 delete_omp_context (splay_tree_value value
)
1285 omp_context
*ctx
= (omp_context
*) value
;
1287 pointer_map_destroy (ctx
->cb
.decl_map
);
1290 splay_tree_delete (ctx
->field_map
);
1291 if (ctx
->sfield_map
)
1292 splay_tree_delete (ctx
->sfield_map
);
1294 /* We hijacked DECL_ABSTRACT_ORIGIN earlier. We need to clear it before
1295 it produces corrupt debug information. */
1296 if (ctx
->record_type
)
1299 for (t
= TYPE_FIELDS (ctx
->record_type
); t
; t
= DECL_CHAIN (t
))
1300 DECL_ABSTRACT_ORIGIN (t
) = NULL
;
1302 if (ctx
->srecord_type
)
1305 for (t
= TYPE_FIELDS (ctx
->srecord_type
); t
; t
= DECL_CHAIN (t
))
1306 DECL_ABSTRACT_ORIGIN (t
) = NULL
;
1309 if (is_task_ctx (ctx
))
1310 finalize_task_copyfn (ctx
->stmt
);
1315 /* Fix up RECEIVER_DECL with a type that has been remapped to the child
1319 fixup_child_record_type (omp_context
*ctx
)
1321 tree f
, type
= ctx
->record_type
;
1323 /* ??? It isn't sufficient to just call remap_type here, because
1324 variably_modified_type_p doesn't work the way we expect for
1325 record types. Testing each field for whether it needs remapping
1326 and creating a new record by hand works, however. */
1327 for (f
= TYPE_FIELDS (type
); f
; f
= DECL_CHAIN (f
))
1328 if (variably_modified_type_p (TREE_TYPE (f
), ctx
->cb
.src_fn
))
1332 tree name
, new_fields
= NULL
;
1334 type
= lang_hooks
.types
.make_type (RECORD_TYPE
);
1335 name
= DECL_NAME (TYPE_NAME (ctx
->record_type
));
1336 name
= build_decl (DECL_SOURCE_LOCATION (ctx
->receiver_decl
),
1337 TYPE_DECL
, name
, type
);
1338 TYPE_NAME (type
) = name
;
1340 for (f
= TYPE_FIELDS (ctx
->record_type
); f
; f
= DECL_CHAIN (f
))
1342 tree new_f
= copy_node (f
);
1343 DECL_CONTEXT (new_f
) = type
;
1344 TREE_TYPE (new_f
) = remap_type (TREE_TYPE (f
), &ctx
->cb
);
1345 DECL_CHAIN (new_f
) = new_fields
;
1346 walk_tree (&DECL_SIZE (new_f
), copy_tree_body_r
, &ctx
->cb
, NULL
);
1347 walk_tree (&DECL_SIZE_UNIT (new_f
), copy_tree_body_r
,
1349 walk_tree (&DECL_FIELD_OFFSET (new_f
), copy_tree_body_r
,
1353 /* Arrange to be able to look up the receiver field
1354 given the sender field. */
1355 splay_tree_insert (ctx
->field_map
, (splay_tree_key
) f
,
1356 (splay_tree_value
) new_f
);
1358 TYPE_FIELDS (type
) = nreverse (new_fields
);
1362 TREE_TYPE (ctx
->receiver_decl
) = build_pointer_type (type
);
1365 /* Instantiate decls as necessary in CTX to satisfy the data sharing
1366 specified by CLAUSES. */
1369 scan_sharing_clauses (tree clauses
, omp_context
*ctx
)
1372 bool scan_array_reductions
= false;
1374 for (c
= clauses
; c
; c
= OMP_CLAUSE_CHAIN (c
))
1378 switch (OMP_CLAUSE_CODE (c
))
1380 case OMP_CLAUSE_PRIVATE
:
1381 decl
= OMP_CLAUSE_DECL (c
);
1382 if (OMP_CLAUSE_PRIVATE_OUTER_REF (c
))
1384 else if (!is_variable_sized (decl
))
1385 install_var_local (decl
, ctx
);
1388 case OMP_CLAUSE_SHARED
:
1389 gcc_assert (is_taskreg_ctx (ctx
));
1390 decl
= OMP_CLAUSE_DECL (c
);
1391 gcc_assert (!COMPLETE_TYPE_P (TREE_TYPE (decl
))
1392 || !is_variable_sized (decl
));
1393 /* Global variables don't need to be copied,
1394 the receiver side will use them directly. */
1395 if (is_global_var (maybe_lookup_decl_in_outer_ctx (decl
, ctx
)))
1397 by_ref
= use_pointer_for_field (decl
, ctx
);
1398 if (! TREE_READONLY (decl
)
1399 || TREE_ADDRESSABLE (decl
)
1401 || is_reference (decl
))
1403 install_var_field (decl
, by_ref
, 3, ctx
);
1404 install_var_local (decl
, ctx
);
1407 /* We don't need to copy const scalar vars back. */
1408 OMP_CLAUSE_SET_CODE (c
, OMP_CLAUSE_FIRSTPRIVATE
);
1411 case OMP_CLAUSE_LASTPRIVATE
:
1412 /* Let the corresponding firstprivate clause create
1414 if (OMP_CLAUSE_LASTPRIVATE_FIRSTPRIVATE (c
))
1418 case OMP_CLAUSE_FIRSTPRIVATE
:
1419 case OMP_CLAUSE_REDUCTION
:
1420 decl
= OMP_CLAUSE_DECL (c
);
1422 if (is_variable_sized (decl
))
1424 if (is_task_ctx (ctx
))
1425 install_var_field (decl
, false, 1, ctx
);
1428 else if (is_taskreg_ctx (ctx
))
1431 = is_global_var (maybe_lookup_decl_in_outer_ctx (decl
, ctx
));
1432 by_ref
= use_pointer_for_field (decl
, NULL
);
1434 if (is_task_ctx (ctx
)
1435 && (global
|| by_ref
|| is_reference (decl
)))
1437 install_var_field (decl
, false, 1, ctx
);
1439 install_var_field (decl
, by_ref
, 2, ctx
);
1442 install_var_field (decl
, by_ref
, 3, ctx
);
1444 install_var_local (decl
, ctx
);
1447 case OMP_CLAUSE_COPYPRIVATE
:
1448 case OMP_CLAUSE_COPYIN
:
1449 decl
= OMP_CLAUSE_DECL (c
);
1450 by_ref
= use_pointer_for_field (decl
, NULL
);
1451 install_var_field (decl
, by_ref
, 3, ctx
);
1454 case OMP_CLAUSE_DEFAULT
:
1455 ctx
->default_kind
= OMP_CLAUSE_DEFAULT_KIND (c
);
1458 case OMP_CLAUSE_FINAL
:
1460 case OMP_CLAUSE_NUM_THREADS
:
1461 case OMP_CLAUSE_SCHEDULE
:
1463 scan_omp_op (&OMP_CLAUSE_OPERAND (c
, 0), ctx
->outer
);
1466 case OMP_CLAUSE_NOWAIT
:
1467 case OMP_CLAUSE_ORDERED
:
1468 case OMP_CLAUSE_COLLAPSE
:
1469 case OMP_CLAUSE_UNTIED
:
1470 case OMP_CLAUSE_MERGEABLE
:
1478 for (c
= clauses
; c
; c
= OMP_CLAUSE_CHAIN (c
))
1480 switch (OMP_CLAUSE_CODE (c
))
1482 case OMP_CLAUSE_LASTPRIVATE
:
1483 /* Let the corresponding firstprivate clause create
1485 if (OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (c
))
1486 scan_array_reductions
= true;
1487 if (OMP_CLAUSE_LASTPRIVATE_FIRSTPRIVATE (c
))
1491 case OMP_CLAUSE_PRIVATE
:
1492 case OMP_CLAUSE_FIRSTPRIVATE
:
1493 case OMP_CLAUSE_REDUCTION
:
1494 decl
= OMP_CLAUSE_DECL (c
);
1495 if (is_variable_sized (decl
))
1496 install_var_local (decl
, ctx
);
1497 fixup_remapped_decl (decl
, ctx
,
1498 OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_PRIVATE
1499 && OMP_CLAUSE_PRIVATE_DEBUG (c
));
1500 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_REDUCTION
1501 && OMP_CLAUSE_REDUCTION_PLACEHOLDER (c
))
1502 scan_array_reductions
= true;
1505 case OMP_CLAUSE_SHARED
:
1506 decl
= OMP_CLAUSE_DECL (c
);
1507 if (! is_global_var (maybe_lookup_decl_in_outer_ctx (decl
, ctx
)))
1508 fixup_remapped_decl (decl
, ctx
, false);
1511 case OMP_CLAUSE_COPYPRIVATE
:
1512 case OMP_CLAUSE_COPYIN
:
1513 case OMP_CLAUSE_DEFAULT
:
1515 case OMP_CLAUSE_NUM_THREADS
:
1516 case OMP_CLAUSE_SCHEDULE
:
1517 case OMP_CLAUSE_NOWAIT
:
1518 case OMP_CLAUSE_ORDERED
:
1519 case OMP_CLAUSE_COLLAPSE
:
1520 case OMP_CLAUSE_UNTIED
:
1521 case OMP_CLAUSE_FINAL
:
1522 case OMP_CLAUSE_MERGEABLE
:
1530 if (scan_array_reductions
)
1531 for (c
= clauses
; c
; c
= OMP_CLAUSE_CHAIN (c
))
1532 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_REDUCTION
1533 && OMP_CLAUSE_REDUCTION_PLACEHOLDER (c
))
1535 scan_omp (&OMP_CLAUSE_REDUCTION_GIMPLE_INIT (c
), ctx
);
1536 scan_omp (&OMP_CLAUSE_REDUCTION_GIMPLE_MERGE (c
), ctx
);
1538 else if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_LASTPRIVATE
1539 && OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (c
))
1540 scan_omp (&OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (c
), ctx
);
1543 /* Create a new name for omp child function. Returns an identifier. */
1545 static GTY(()) unsigned int tmp_ompfn_id_num
;
1548 create_omp_child_function_name (bool task_copy
)
1550 return (clone_function_name (current_function_decl
,
1551 task_copy
? "_omp_cpyfn" : "_omp_fn"));
1554 /* Build a decl for the omp child function. It'll not contain a body
1555 yet, just the bare decl. */
1558 create_omp_child_function (omp_context
*ctx
, bool task_copy
)
1560 tree decl
, type
, name
, t
;
1562 name
= create_omp_child_function_name (task_copy
);
1564 type
= build_function_type_list (void_type_node
, ptr_type_node
,
1565 ptr_type_node
, NULL_TREE
);
1567 type
= build_function_type_list (void_type_node
, ptr_type_node
, NULL_TREE
);
1569 decl
= build_decl (gimple_location (ctx
->stmt
),
1570 FUNCTION_DECL
, name
, type
);
1573 ctx
->cb
.dst_fn
= decl
;
1575 gimple_omp_task_set_copy_fn (ctx
->stmt
, decl
);
1577 TREE_STATIC (decl
) = 1;
1578 TREE_USED (decl
) = 1;
1579 DECL_ARTIFICIAL (decl
) = 1;
1580 DECL_NAMELESS (decl
) = 1;
1581 DECL_IGNORED_P (decl
) = 0;
1582 TREE_PUBLIC (decl
) = 0;
1583 DECL_UNINLINABLE (decl
) = 1;
1584 DECL_EXTERNAL (decl
) = 0;
1585 DECL_CONTEXT (decl
) = NULL_TREE
;
1586 DECL_INITIAL (decl
) = make_node (BLOCK
);
1588 t
= build_decl (DECL_SOURCE_LOCATION (decl
),
1589 RESULT_DECL
, NULL_TREE
, void_type_node
);
1590 DECL_ARTIFICIAL (t
) = 1;
1591 DECL_IGNORED_P (t
) = 1;
1592 DECL_CONTEXT (t
) = decl
;
1593 DECL_RESULT (decl
) = t
;
1595 t
= build_decl (DECL_SOURCE_LOCATION (decl
),
1596 PARM_DECL
, get_identifier (".omp_data_i"), ptr_type_node
);
1597 DECL_ARTIFICIAL (t
) = 1;
1598 DECL_NAMELESS (t
) = 1;
1599 DECL_ARG_TYPE (t
) = ptr_type_node
;
1600 DECL_CONTEXT (t
) = current_function_decl
;
1602 DECL_ARGUMENTS (decl
) = t
;
1604 ctx
->receiver_decl
= t
;
1607 t
= build_decl (DECL_SOURCE_LOCATION (decl
),
1608 PARM_DECL
, get_identifier (".omp_data_o"),
1610 DECL_ARTIFICIAL (t
) = 1;
1611 DECL_NAMELESS (t
) = 1;
1612 DECL_ARG_TYPE (t
) = ptr_type_node
;
1613 DECL_CONTEXT (t
) = current_function_decl
;
1615 TREE_ADDRESSABLE (t
) = 1;
1616 DECL_CHAIN (t
) = DECL_ARGUMENTS (decl
);
1617 DECL_ARGUMENTS (decl
) = t
;
1620 /* Allocate memory for the function structure. The call to
1621 allocate_struct_function clobbers CFUN, so we need to restore
1623 push_struct_function (decl
);
1624 cfun
->function_end_locus
= gimple_location (ctx
->stmt
);
1629 /* Scan an OpenMP parallel directive. */
1632 scan_omp_parallel (gimple_stmt_iterator
*gsi
, omp_context
*outer_ctx
)
1636 gimple stmt
= gsi_stmt (*gsi
);
1638 /* Ignore parallel directives with empty bodies, unless there
1639 are copyin clauses. */
1641 && empty_body_p (gimple_omp_body (stmt
))
1642 && find_omp_clause (gimple_omp_parallel_clauses (stmt
),
1643 OMP_CLAUSE_COPYIN
) == NULL
)
1645 gsi_replace (gsi
, gimple_build_nop (), false);
1649 ctx
= new_omp_context (stmt
, outer_ctx
);
1650 if (taskreg_nesting_level
> 1)
1651 ctx
->is_nested
= true;
1652 ctx
->field_map
= splay_tree_new (splay_tree_compare_pointers
, 0, 0);
1653 ctx
->default_kind
= OMP_CLAUSE_DEFAULT_SHARED
;
1654 ctx
->record_type
= lang_hooks
.types
.make_type (RECORD_TYPE
);
1655 name
= create_tmp_var_name (".omp_data_s");
1656 name
= build_decl (gimple_location (stmt
),
1657 TYPE_DECL
, name
, ctx
->record_type
);
1658 DECL_ARTIFICIAL (name
) = 1;
1659 DECL_NAMELESS (name
) = 1;
1660 TYPE_NAME (ctx
->record_type
) = name
;
1661 create_omp_child_function (ctx
, false);
1662 gimple_omp_parallel_set_child_fn (stmt
, ctx
->cb
.dst_fn
);
1664 scan_sharing_clauses (gimple_omp_parallel_clauses (stmt
), ctx
);
1665 scan_omp (gimple_omp_body_ptr (stmt
), ctx
);
1667 if (TYPE_FIELDS (ctx
->record_type
) == NULL
)
1668 ctx
->record_type
= ctx
->receiver_decl
= NULL
;
1671 layout_type (ctx
->record_type
);
1672 fixup_child_record_type (ctx
);
1676 /* Scan an OpenMP task directive. */
1679 scan_omp_task (gimple_stmt_iterator
*gsi
, omp_context
*outer_ctx
)
1683 gimple stmt
= gsi_stmt (*gsi
);
1684 location_t loc
= gimple_location (stmt
);
1686 /* Ignore task directives with empty bodies. */
1688 && empty_body_p (gimple_omp_body (stmt
)))
1690 gsi_replace (gsi
, gimple_build_nop (), false);
1694 ctx
= new_omp_context (stmt
, outer_ctx
);
1695 if (taskreg_nesting_level
> 1)
1696 ctx
->is_nested
= true;
1697 ctx
->field_map
= splay_tree_new (splay_tree_compare_pointers
, 0, 0);
1698 ctx
->default_kind
= OMP_CLAUSE_DEFAULT_SHARED
;
1699 ctx
->record_type
= lang_hooks
.types
.make_type (RECORD_TYPE
);
1700 name
= create_tmp_var_name (".omp_data_s");
1701 name
= build_decl (gimple_location (stmt
),
1702 TYPE_DECL
, name
, ctx
->record_type
);
1703 DECL_ARTIFICIAL (name
) = 1;
1704 DECL_NAMELESS (name
) = 1;
1705 TYPE_NAME (ctx
->record_type
) = name
;
1706 create_omp_child_function (ctx
, false);
1707 gimple_omp_task_set_child_fn (stmt
, ctx
->cb
.dst_fn
);
1709 scan_sharing_clauses (gimple_omp_task_clauses (stmt
), ctx
);
1711 if (ctx
->srecord_type
)
1713 name
= create_tmp_var_name (".omp_data_a");
1714 name
= build_decl (gimple_location (stmt
),
1715 TYPE_DECL
, name
, ctx
->srecord_type
);
1716 DECL_ARTIFICIAL (name
) = 1;
1717 DECL_NAMELESS (name
) = 1;
1718 TYPE_NAME (ctx
->srecord_type
) = name
;
1719 create_omp_child_function (ctx
, true);
1722 scan_omp (gimple_omp_body_ptr (stmt
), ctx
);
1724 if (TYPE_FIELDS (ctx
->record_type
) == NULL
)
1726 ctx
->record_type
= ctx
->receiver_decl
= NULL
;
1727 t
= build_int_cst (long_integer_type_node
, 0);
1728 gimple_omp_task_set_arg_size (stmt
, t
);
1729 t
= build_int_cst (long_integer_type_node
, 1);
1730 gimple_omp_task_set_arg_align (stmt
, t
);
1734 tree
*p
, vla_fields
= NULL_TREE
, *q
= &vla_fields
;
1735 /* Move VLA fields to the end. */
1736 p
= &TYPE_FIELDS (ctx
->record_type
);
1738 if (!TYPE_SIZE_UNIT (TREE_TYPE (*p
))
1739 || ! TREE_CONSTANT (TYPE_SIZE_UNIT (TREE_TYPE (*p
))))
1742 *p
= TREE_CHAIN (*p
);
1743 TREE_CHAIN (*q
) = NULL_TREE
;
1744 q
= &TREE_CHAIN (*q
);
1747 p
= &DECL_CHAIN (*p
);
1749 layout_type (ctx
->record_type
);
1750 fixup_child_record_type (ctx
);
1751 if (ctx
->srecord_type
)
1752 layout_type (ctx
->srecord_type
);
1753 t
= fold_convert_loc (loc
, long_integer_type_node
,
1754 TYPE_SIZE_UNIT (ctx
->record_type
));
1755 gimple_omp_task_set_arg_size (stmt
, t
);
1756 t
= build_int_cst (long_integer_type_node
,
1757 TYPE_ALIGN_UNIT (ctx
->record_type
));
1758 gimple_omp_task_set_arg_align (stmt
, t
);
1763 /* Scan an OpenMP loop directive. */
1766 scan_omp_for (gimple stmt
, omp_context
*outer_ctx
)
1771 ctx
= new_omp_context (stmt
, outer_ctx
);
1773 scan_sharing_clauses (gimple_omp_for_clauses (stmt
), ctx
);
1775 scan_omp (gimple_omp_for_pre_body_ptr (stmt
), ctx
);
1776 for (i
= 0; i
< gimple_omp_for_collapse (stmt
); i
++)
1778 scan_omp_op (gimple_omp_for_index_ptr (stmt
, i
), ctx
);
1779 scan_omp_op (gimple_omp_for_initial_ptr (stmt
, i
), ctx
);
1780 scan_omp_op (gimple_omp_for_final_ptr (stmt
, i
), ctx
);
1781 scan_omp_op (gimple_omp_for_incr_ptr (stmt
, i
), ctx
);
1783 scan_omp (gimple_omp_body_ptr (stmt
), ctx
);
1786 /* Scan an OpenMP sections directive. */
1789 scan_omp_sections (gimple stmt
, omp_context
*outer_ctx
)
1793 ctx
= new_omp_context (stmt
, outer_ctx
);
1794 scan_sharing_clauses (gimple_omp_sections_clauses (stmt
), ctx
);
1795 scan_omp (gimple_omp_body_ptr (stmt
), ctx
);
1798 /* Scan an OpenMP single directive. */
1801 scan_omp_single (gimple stmt
, omp_context
*outer_ctx
)
1806 ctx
= new_omp_context (stmt
, outer_ctx
);
1807 ctx
->field_map
= splay_tree_new (splay_tree_compare_pointers
, 0, 0);
1808 ctx
->record_type
= lang_hooks
.types
.make_type (RECORD_TYPE
);
1809 name
= create_tmp_var_name (".omp_copy_s");
1810 name
= build_decl (gimple_location (stmt
),
1811 TYPE_DECL
, name
, ctx
->record_type
);
1812 TYPE_NAME (ctx
->record_type
) = name
;
1814 scan_sharing_clauses (gimple_omp_single_clauses (stmt
), ctx
);
1815 scan_omp (gimple_omp_body_ptr (stmt
), ctx
);
1817 if (TYPE_FIELDS (ctx
->record_type
) == NULL
)
1818 ctx
->record_type
= NULL
;
1820 layout_type (ctx
->record_type
);
1824 /* Check OpenMP nesting restrictions. */
1826 check_omp_nesting_restrictions (gimple stmt
, omp_context
*ctx
)
1828 switch (gimple_code (stmt
))
1830 case GIMPLE_OMP_FOR
:
1831 case GIMPLE_OMP_SECTIONS
:
1832 case GIMPLE_OMP_SINGLE
:
1834 for (; ctx
!= NULL
; ctx
= ctx
->outer
)
1835 switch (gimple_code (ctx
->stmt
))
1837 case GIMPLE_OMP_FOR
:
1838 case GIMPLE_OMP_SECTIONS
:
1839 case GIMPLE_OMP_SINGLE
:
1840 case GIMPLE_OMP_ORDERED
:
1841 case GIMPLE_OMP_MASTER
:
1842 case GIMPLE_OMP_TASK
:
1843 if (is_gimple_call (stmt
))
1845 error_at (gimple_location (stmt
),
1846 "barrier region may not be closely nested inside "
1847 "of work-sharing, critical, ordered, master or "
1848 "explicit task region");
1851 error_at (gimple_location (stmt
),
1852 "work-sharing region may not be closely nested inside "
1853 "of work-sharing, critical, ordered, master or explicit "
1856 case GIMPLE_OMP_PARALLEL
:
1862 case GIMPLE_OMP_MASTER
:
1863 for (; ctx
!= NULL
; ctx
= ctx
->outer
)
1864 switch (gimple_code (ctx
->stmt
))
1866 case GIMPLE_OMP_FOR
:
1867 case GIMPLE_OMP_SECTIONS
:
1868 case GIMPLE_OMP_SINGLE
:
1869 case GIMPLE_OMP_TASK
:
1870 error_at (gimple_location (stmt
),
1871 "master region may not be closely nested inside "
1872 "of work-sharing or explicit task region");
1874 case GIMPLE_OMP_PARALLEL
:
1880 case GIMPLE_OMP_ORDERED
:
1881 for (; ctx
!= NULL
; ctx
= ctx
->outer
)
1882 switch (gimple_code (ctx
->stmt
))
1884 case GIMPLE_OMP_CRITICAL
:
1885 case GIMPLE_OMP_TASK
:
1886 error_at (gimple_location (stmt
),
1887 "ordered region may not be closely nested inside "
1888 "of critical or explicit task region");
1890 case GIMPLE_OMP_FOR
:
1891 if (find_omp_clause (gimple_omp_for_clauses (ctx
->stmt
),
1892 OMP_CLAUSE_ORDERED
) == NULL
)
1894 error_at (gimple_location (stmt
),
1895 "ordered region must be closely nested inside "
1896 "a loop region with an ordered clause");
1900 case GIMPLE_OMP_PARALLEL
:
1906 case GIMPLE_OMP_CRITICAL
:
1907 for (; ctx
!= NULL
; ctx
= ctx
->outer
)
1908 if (gimple_code (ctx
->stmt
) == GIMPLE_OMP_CRITICAL
1909 && (gimple_omp_critical_name (stmt
)
1910 == gimple_omp_critical_name (ctx
->stmt
)))
1912 error_at (gimple_location (stmt
),
1913 "critical region may not be nested inside a critical "
1914 "region with the same name");
1925 /* Helper function scan_omp.
1927 Callback for walk_tree or operators in walk_gimple_stmt used to
1928 scan for OpenMP directives in TP. */
1931 scan_omp_1_op (tree
*tp
, int *walk_subtrees
, void *data
)
1933 struct walk_stmt_info
*wi
= (struct walk_stmt_info
*) data
;
1934 omp_context
*ctx
= (omp_context
*) wi
->info
;
1937 switch (TREE_CODE (t
))
1944 *tp
= remap_decl (t
, &ctx
->cb
);
1948 if (ctx
&& TYPE_P (t
))
1949 *tp
= remap_type (t
, &ctx
->cb
);
1950 else if (!DECL_P (t
))
1955 tree tem
= remap_type (TREE_TYPE (t
), &ctx
->cb
);
1956 if (tem
!= TREE_TYPE (t
))
1958 if (TREE_CODE (t
) == INTEGER_CST
)
1959 *tp
= build_int_cst_wide (tem
,
1960 TREE_INT_CST_LOW (t
),
1961 TREE_INT_CST_HIGH (t
));
1963 TREE_TYPE (t
) = tem
;
1974 /* Helper function for scan_omp.
1976 Callback for walk_gimple_stmt used to scan for OpenMP directives in
1977 the current statement in GSI. */
1980 scan_omp_1_stmt (gimple_stmt_iterator
*gsi
, bool *handled_ops_p
,
1981 struct walk_stmt_info
*wi
)
1983 gimple stmt
= gsi_stmt (*gsi
);
1984 omp_context
*ctx
= (omp_context
*) wi
->info
;
1986 if (gimple_has_location (stmt
))
1987 input_location
= gimple_location (stmt
);
1989 /* Check the OpenMP nesting restrictions. */
1992 bool remove
= false;
1993 if (is_gimple_omp (stmt
))
1994 remove
= !check_omp_nesting_restrictions (stmt
, ctx
);
1995 else if (is_gimple_call (stmt
))
1997 tree fndecl
= gimple_call_fndecl (stmt
);
1998 if (fndecl
&& DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_NORMAL
1999 && DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_GOMP_BARRIER
)
2000 remove
= !check_omp_nesting_restrictions (stmt
, ctx
);
2004 stmt
= gimple_build_nop ();
2005 gsi_replace (gsi
, stmt
, false);
2009 *handled_ops_p
= true;
2011 switch (gimple_code (stmt
))
2013 case GIMPLE_OMP_PARALLEL
:
2014 taskreg_nesting_level
++;
2015 scan_omp_parallel (gsi
, ctx
);
2016 taskreg_nesting_level
--;
2019 case GIMPLE_OMP_TASK
:
2020 taskreg_nesting_level
++;
2021 scan_omp_task (gsi
, ctx
);
2022 taskreg_nesting_level
--;
2025 case GIMPLE_OMP_FOR
:
2026 scan_omp_for (stmt
, ctx
);
2029 case GIMPLE_OMP_SECTIONS
:
2030 scan_omp_sections (stmt
, ctx
);
2033 case GIMPLE_OMP_SINGLE
:
2034 scan_omp_single (stmt
, ctx
);
2037 case GIMPLE_OMP_SECTION
:
2038 case GIMPLE_OMP_MASTER
:
2039 case GIMPLE_OMP_ORDERED
:
2040 case GIMPLE_OMP_CRITICAL
:
2041 ctx
= new_omp_context (stmt
, ctx
);
2042 scan_omp (gimple_omp_body_ptr (stmt
), ctx
);
2049 *handled_ops_p
= false;
2051 for (var
= gimple_bind_vars (stmt
); var
; var
= DECL_CHAIN (var
))
2052 insert_decl_map (&ctx
->cb
, var
, var
);
2056 *handled_ops_p
= false;
2064 /* Scan all the statements starting at the current statement. CTX
2065 contains context information about the OpenMP directives and
2066 clauses found during the scan. */
2069 scan_omp (gimple_seq
*body_p
, omp_context
*ctx
)
2071 location_t saved_location
;
2072 struct walk_stmt_info wi
;
2074 memset (&wi
, 0, sizeof (wi
));
2076 wi
.want_locations
= true;
2078 saved_location
= input_location
;
2079 walk_gimple_seq_mod (body_p
, scan_omp_1_stmt
, scan_omp_1_op
, &wi
);
2080 input_location
= saved_location
;
2083 /* Re-gimplification and code generation routines. */
2085 /* Build a call to GOMP_barrier. */
2088 build_omp_barrier (void)
2090 return build_call_expr (builtin_decl_explicit (BUILT_IN_GOMP_BARRIER
), 0);
2093 /* If a context was created for STMT when it was scanned, return it. */
2095 static omp_context
*
2096 maybe_lookup_ctx (gimple stmt
)
2099 n
= splay_tree_lookup (all_contexts
, (splay_tree_key
) stmt
);
2100 return n
? (omp_context
*) n
->value
: NULL
;
2104 /* Find the mapping for DECL in CTX or the immediately enclosing
2105 context that has a mapping for DECL.
2107 If CTX is a nested parallel directive, we may have to use the decl
2108 mappings created in CTX's parent context. Suppose that we have the
2109 following parallel nesting (variable UIDs showed for clarity):
2112 #omp parallel shared(iD.1562) -> outer parallel
2113 iD.1562 = iD.1562 + 1;
2115 #omp parallel shared (iD.1562) -> inner parallel
2116 iD.1562 = iD.1562 - 1;
2118 Each parallel structure will create a distinct .omp_data_s structure
2119 for copying iD.1562 in/out of the directive:
2121 outer parallel .omp_data_s.1.i -> iD.1562
2122 inner parallel .omp_data_s.2.i -> iD.1562
2124 A shared variable mapping will produce a copy-out operation before
2125 the parallel directive and a copy-in operation after it. So, in
2126 this case we would have:
2129 .omp_data_o.1.i = iD.1562;
2130 #omp parallel shared(iD.1562) -> outer parallel
2131 .omp_data_i.1 = &.omp_data_o.1
2132 .omp_data_i.1->i = .omp_data_i.1->i + 1;
2134 .omp_data_o.2.i = iD.1562; -> **
2135 #omp parallel shared(iD.1562) -> inner parallel
2136 .omp_data_i.2 = &.omp_data_o.2
2137 .omp_data_i.2->i = .omp_data_i.2->i - 1;
2140 ** This is a problem. The symbol iD.1562 cannot be referenced
2141 inside the body of the outer parallel region. But since we are
2142 emitting this copy operation while expanding the inner parallel
2143 directive, we need to access the CTX structure of the outer
2144 parallel directive to get the correct mapping:
2146 .omp_data_o.2.i = .omp_data_i.1->i
2148 Since there may be other workshare or parallel directives enclosing
2149 the parallel directive, it may be necessary to walk up the context
2150 parent chain. This is not a problem in general because nested
2151 parallelism happens only rarely. */
2154 lookup_decl_in_outer_ctx (tree decl
, omp_context
*ctx
)
2159 for (up
= ctx
->outer
, t
= NULL
; up
&& t
== NULL
; up
= up
->outer
)
2160 t
= maybe_lookup_decl (decl
, up
);
2162 gcc_assert (!ctx
->is_nested
|| t
|| is_global_var (decl
));
2164 return t
? t
: decl
;
2168 /* Similar to lookup_decl_in_outer_ctx, but return DECL if not found
2169 in outer contexts. */
2172 maybe_lookup_decl_in_outer_ctx (tree decl
, omp_context
*ctx
)
2177 for (up
= ctx
->outer
, t
= NULL
; up
&& t
== NULL
; up
= up
->outer
)
2178 t
= maybe_lookup_decl (decl
, up
);
2180 return t
? t
: decl
;
2184 /* Construct the initialization value for reduction CLAUSE. */
2187 omp_reduction_init (tree clause
, tree type
)
2189 location_t loc
= OMP_CLAUSE_LOCATION (clause
);
2190 switch (OMP_CLAUSE_REDUCTION_CODE (clause
))
2197 case TRUTH_ORIF_EXPR
:
2198 case TRUTH_XOR_EXPR
:
2200 return build_zero_cst (type
);
2203 case TRUTH_AND_EXPR
:
2204 case TRUTH_ANDIF_EXPR
:
2206 return fold_convert_loc (loc
, type
, integer_one_node
);
2209 return fold_convert_loc (loc
, type
, integer_minus_one_node
);
2212 if (SCALAR_FLOAT_TYPE_P (type
))
2214 REAL_VALUE_TYPE max
, min
;
2215 if (HONOR_INFINITIES (TYPE_MODE (type
)))
2218 real_arithmetic (&min
, NEGATE_EXPR
, &max
, NULL
);
2221 real_maxval (&min
, 1, TYPE_MODE (type
));
2222 return build_real (type
, min
);
2226 gcc_assert (INTEGRAL_TYPE_P (type
));
2227 return TYPE_MIN_VALUE (type
);
2231 if (SCALAR_FLOAT_TYPE_P (type
))
2233 REAL_VALUE_TYPE max
;
2234 if (HONOR_INFINITIES (TYPE_MODE (type
)))
2237 real_maxval (&max
, 0, TYPE_MODE (type
));
2238 return build_real (type
, max
);
2242 gcc_assert (INTEGRAL_TYPE_P (type
));
2243 return TYPE_MAX_VALUE (type
);
2251 /* Generate code to implement the input clauses, FIRSTPRIVATE and COPYIN,
2252 from the receiver (aka child) side and initializers for REFERENCE_TYPE
2253 private variables. Initialization statements go in ILIST, while calls
2254 to destructors go in DLIST. */
2257 lower_rec_input_clauses (tree clauses
, gimple_seq
*ilist
, gimple_seq
*dlist
,
2260 tree c
, dtor
, copyin_seq
, x
, ptr
;
2261 bool copyin_by_ref
= false;
2262 bool lastprivate_firstprivate
= false;
2267 /* Do all the fixed sized types in the first pass, and the variable sized
2268 types in the second pass. This makes sure that the scalar arguments to
2269 the variable sized types are processed before we use them in the
2270 variable sized operations. */
2271 for (pass
= 0; pass
< 2; ++pass
)
2273 for (c
= clauses
; c
; c
= OMP_CLAUSE_CHAIN (c
))
2275 enum omp_clause_code c_kind
= OMP_CLAUSE_CODE (c
);
2278 location_t clause_loc
= OMP_CLAUSE_LOCATION (c
);
2282 case OMP_CLAUSE_PRIVATE
:
2283 if (OMP_CLAUSE_PRIVATE_DEBUG (c
))
2286 case OMP_CLAUSE_SHARED
:
2287 if (maybe_lookup_decl (OMP_CLAUSE_DECL (c
), ctx
) == NULL
)
2289 gcc_assert (is_global_var (OMP_CLAUSE_DECL (c
)));
2292 case OMP_CLAUSE_FIRSTPRIVATE
:
2293 case OMP_CLAUSE_COPYIN
:
2294 case OMP_CLAUSE_REDUCTION
:
2296 case OMP_CLAUSE_LASTPRIVATE
:
2297 if (OMP_CLAUSE_LASTPRIVATE_FIRSTPRIVATE (c
))
2299 lastprivate_firstprivate
= true;
2308 new_var
= var
= OMP_CLAUSE_DECL (c
);
2309 if (c_kind
!= OMP_CLAUSE_COPYIN
)
2310 new_var
= lookup_decl (var
, ctx
);
2312 if (c_kind
== OMP_CLAUSE_SHARED
|| c_kind
== OMP_CLAUSE_COPYIN
)
2317 else if (is_variable_sized (var
))
2319 /* For variable sized types, we need to allocate the
2320 actual storage here. Call alloca and store the
2321 result in the pointer decl that we created elsewhere. */
2325 if (c_kind
!= OMP_CLAUSE_FIRSTPRIVATE
|| !is_task_ctx (ctx
))
2330 ptr
= DECL_VALUE_EXPR (new_var
);
2331 gcc_assert (TREE_CODE (ptr
) == INDIRECT_REF
);
2332 ptr
= TREE_OPERAND (ptr
, 0);
2333 gcc_assert (DECL_P (ptr
));
2334 x
= TYPE_SIZE_UNIT (TREE_TYPE (new_var
));
2336 /* void *tmp = __builtin_alloca */
2337 atmp
= builtin_decl_explicit (BUILT_IN_ALLOCA
);
2338 stmt
= gimple_build_call (atmp
, 1, x
);
2339 tmp
= create_tmp_var_raw (ptr_type_node
, NULL
);
2340 gimple_add_tmp_var (tmp
);
2341 gimple_call_set_lhs (stmt
, tmp
);
2343 gimple_seq_add_stmt (ilist
, stmt
);
2345 x
= fold_convert_loc (clause_loc
, TREE_TYPE (ptr
), tmp
);
2346 gimplify_assign (ptr
, x
, ilist
);
2349 else if (is_reference (var
))
2351 /* For references that are being privatized for Fortran,
2352 allocate new backing storage for the new pointer
2353 variable. This allows us to avoid changing all the
2354 code that expects a pointer to something that expects
2355 a direct variable. Note that this doesn't apply to
2356 C++, since reference types are disallowed in data
2357 sharing clauses there, except for NRV optimized
2362 x
= TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (new_var
)));
2363 if (c_kind
== OMP_CLAUSE_FIRSTPRIVATE
&& is_task_ctx (ctx
))
2365 x
= build_receiver_ref (var
, false, ctx
);
2366 x
= build_fold_addr_expr_loc (clause_loc
, x
);
2368 else if (TREE_CONSTANT (x
))
2370 const char *name
= NULL
;
2371 if (DECL_NAME (var
))
2372 name
= IDENTIFIER_POINTER (DECL_NAME (new_var
));
2374 x
= create_tmp_var_raw (TREE_TYPE (TREE_TYPE (new_var
)),
2376 gimple_add_tmp_var (x
);
2377 TREE_ADDRESSABLE (x
) = 1;
2378 x
= build_fold_addr_expr_loc (clause_loc
, x
);
2382 tree atmp
= builtin_decl_explicit (BUILT_IN_ALLOCA
);
2383 x
= build_call_expr_loc (clause_loc
, atmp
, 1, x
);
2386 x
= fold_convert_loc (clause_loc
, TREE_TYPE (new_var
), x
);
2387 gimplify_assign (new_var
, x
, ilist
);
2389 new_var
= build_simple_mem_ref_loc (clause_loc
, new_var
);
2391 else if (c_kind
== OMP_CLAUSE_REDUCTION
2392 && OMP_CLAUSE_REDUCTION_PLACEHOLDER (c
))
2400 switch (OMP_CLAUSE_CODE (c
))
2402 case OMP_CLAUSE_SHARED
:
2403 /* Shared global vars are just accessed directly. */
2404 if (is_global_var (new_var
))
2406 /* Set up the DECL_VALUE_EXPR for shared variables now. This
2407 needs to be delayed until after fixup_child_record_type so
2408 that we get the correct type during the dereference. */
2409 by_ref
= use_pointer_for_field (var
, ctx
);
2410 x
= build_receiver_ref (var
, by_ref
, ctx
);
2411 SET_DECL_VALUE_EXPR (new_var
, x
);
2412 DECL_HAS_VALUE_EXPR_P (new_var
) = 1;
2414 /* ??? If VAR is not passed by reference, and the variable
2415 hasn't been initialized yet, then we'll get a warning for
2416 the store into the omp_data_s structure. Ideally, we'd be
2417 able to notice this and not store anything at all, but
2418 we're generating code too early. Suppress the warning. */
2420 TREE_NO_WARNING (var
) = 1;
2423 case OMP_CLAUSE_LASTPRIVATE
:
2424 if (OMP_CLAUSE_LASTPRIVATE_FIRSTPRIVATE (c
))
2428 case OMP_CLAUSE_PRIVATE
:
2429 if (OMP_CLAUSE_CODE (c
) != OMP_CLAUSE_PRIVATE
)
2430 x
= build_outer_var_ref (var
, ctx
);
2431 else if (OMP_CLAUSE_PRIVATE_OUTER_REF (c
))
2433 if (is_task_ctx (ctx
))
2434 x
= build_receiver_ref (var
, false, ctx
);
2436 x
= build_outer_var_ref (var
, ctx
);
2440 x
= lang_hooks
.decls
.omp_clause_default_ctor (c
, new_var
, x
);
2442 gimplify_and_add (x
, ilist
);
2446 x
= lang_hooks
.decls
.omp_clause_dtor (c
, new_var
);
2449 gimple_seq tseq
= NULL
;
2452 gimplify_stmt (&dtor
, &tseq
);
2453 gimple_seq_add_seq (dlist
, tseq
);
2457 case OMP_CLAUSE_FIRSTPRIVATE
:
2458 if (is_task_ctx (ctx
))
2460 if (is_reference (var
) || is_variable_sized (var
))
2462 else if (is_global_var (maybe_lookup_decl_in_outer_ctx (var
,
2464 || use_pointer_for_field (var
, NULL
))
2466 x
= build_receiver_ref (var
, false, ctx
);
2467 SET_DECL_VALUE_EXPR (new_var
, x
);
2468 DECL_HAS_VALUE_EXPR_P (new_var
) = 1;
2472 x
= build_outer_var_ref (var
, ctx
);
2473 x
= lang_hooks
.decls
.omp_clause_copy_ctor (c
, new_var
, x
);
2474 gimplify_and_add (x
, ilist
);
2478 case OMP_CLAUSE_COPYIN
:
2479 by_ref
= use_pointer_for_field (var
, NULL
);
2480 x
= build_receiver_ref (var
, by_ref
, ctx
);
2481 x
= lang_hooks
.decls
.omp_clause_assign_op (c
, new_var
, x
);
2482 append_to_statement_list (x
, ©in_seq
);
2483 copyin_by_ref
|= by_ref
;
2486 case OMP_CLAUSE_REDUCTION
:
2487 if (OMP_CLAUSE_REDUCTION_PLACEHOLDER (c
))
2489 tree placeholder
= OMP_CLAUSE_REDUCTION_PLACEHOLDER (c
);
2490 x
= build_outer_var_ref (var
, ctx
);
2492 if (is_reference (var
))
2493 x
= build_fold_addr_expr_loc (clause_loc
, x
);
2494 SET_DECL_VALUE_EXPR (placeholder
, x
);
2495 DECL_HAS_VALUE_EXPR_P (placeholder
) = 1;
2496 lower_omp (&OMP_CLAUSE_REDUCTION_GIMPLE_INIT (c
), ctx
);
2497 gimple_seq_add_seq (ilist
,
2498 OMP_CLAUSE_REDUCTION_GIMPLE_INIT (c
));
2499 OMP_CLAUSE_REDUCTION_GIMPLE_INIT (c
) = NULL
;
2500 DECL_HAS_VALUE_EXPR_P (placeholder
) = 0;
2504 x
= omp_reduction_init (c
, TREE_TYPE (new_var
));
2505 gcc_assert (TREE_CODE (TREE_TYPE (new_var
)) != ARRAY_TYPE
);
2506 gimplify_assign (new_var
, x
, ilist
);
2516 /* The copyin sequence is not to be executed by the main thread, since
2517 that would result in self-copies. Perhaps not visible to scalars,
2518 but it certainly is to C++ operator=. */
2521 x
= build_call_expr (builtin_decl_explicit (BUILT_IN_OMP_GET_THREAD_NUM
),
2523 x
= build2 (NE_EXPR
, boolean_type_node
, x
,
2524 build_int_cst (TREE_TYPE (x
), 0));
2525 x
= build3 (COND_EXPR
, void_type_node
, x
, copyin_seq
, NULL
);
2526 gimplify_and_add (x
, ilist
);
2529 /* If any copyin variable is passed by reference, we must ensure the
2530 master thread doesn't modify it before it is copied over in all
2531 threads. Similarly for variables in both firstprivate and
2532 lastprivate clauses we need to ensure the lastprivate copying
2533 happens after firstprivate copying in all threads. */
2534 if (copyin_by_ref
|| lastprivate_firstprivate
)
2535 gimplify_and_add (build_omp_barrier (), ilist
);
2539 /* Generate code to implement the LASTPRIVATE clauses. This is used for
2540 both parallel and workshare constructs. PREDICATE may be NULL if it's
2544 lower_lastprivate_clauses (tree clauses
, tree predicate
, gimple_seq
*stmt_list
,
2547 tree x
, c
, label
= NULL
;
2548 bool par_clauses
= false;
2550 /* Early exit if there are no lastprivate clauses. */
2551 clauses
= find_omp_clause (clauses
, OMP_CLAUSE_LASTPRIVATE
);
2552 if (clauses
== NULL
)
2554 /* If this was a workshare clause, see if it had been combined
2555 with its parallel. In that case, look for the clauses on the
2556 parallel statement itself. */
2557 if (is_parallel_ctx (ctx
))
2561 if (ctx
== NULL
|| !is_parallel_ctx (ctx
))
2564 clauses
= find_omp_clause (gimple_omp_parallel_clauses (ctx
->stmt
),
2565 OMP_CLAUSE_LASTPRIVATE
);
2566 if (clauses
== NULL
)
2574 tree label_true
, arm1
, arm2
;
2576 label
= create_artificial_label (UNKNOWN_LOCATION
);
2577 label_true
= create_artificial_label (UNKNOWN_LOCATION
);
2578 arm1
= TREE_OPERAND (predicate
, 0);
2579 arm2
= TREE_OPERAND (predicate
, 1);
2580 gimplify_expr (&arm1
, stmt_list
, NULL
, is_gimple_val
, fb_rvalue
);
2581 gimplify_expr (&arm2
, stmt_list
, NULL
, is_gimple_val
, fb_rvalue
);
2582 stmt
= gimple_build_cond (TREE_CODE (predicate
), arm1
, arm2
,
2584 gimple_seq_add_stmt (stmt_list
, stmt
);
2585 gimple_seq_add_stmt (stmt_list
, gimple_build_label (label_true
));
2588 for (c
= clauses
; c
;)
2591 location_t clause_loc
= OMP_CLAUSE_LOCATION (c
);
2593 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_LASTPRIVATE
)
2595 var
= OMP_CLAUSE_DECL (c
);
2596 new_var
= lookup_decl (var
, ctx
);
2598 if (OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (c
))
2600 lower_omp (&OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (c
), ctx
);
2601 gimple_seq_add_seq (stmt_list
,
2602 OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (c
));
2604 OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (c
) = NULL
;
2606 x
= build_outer_var_ref (var
, ctx
);
2607 if (is_reference (var
))
2608 new_var
= build_simple_mem_ref_loc (clause_loc
, new_var
);
2609 x
= lang_hooks
.decls
.omp_clause_assign_op (c
, x
, new_var
);
2610 gimplify_and_add (x
, stmt_list
);
2612 c
= OMP_CLAUSE_CHAIN (c
);
2613 if (c
== NULL
&& !par_clauses
)
2615 /* If this was a workshare clause, see if it had been combined
2616 with its parallel. In that case, continue looking for the
2617 clauses also on the parallel statement itself. */
2618 if (is_parallel_ctx (ctx
))
2622 if (ctx
== NULL
|| !is_parallel_ctx (ctx
))
2625 c
= find_omp_clause (gimple_omp_parallel_clauses (ctx
->stmt
),
2626 OMP_CLAUSE_LASTPRIVATE
);
2632 gimple_seq_add_stmt (stmt_list
, gimple_build_label (label
));
2636 /* Generate code to implement the REDUCTION clauses. */
2639 lower_reduction_clauses (tree clauses
, gimple_seq
*stmt_seqp
, omp_context
*ctx
)
2641 gimple_seq sub_seq
= NULL
;
2646 /* First see if there is exactly one reduction clause. Use OMP_ATOMIC
2647 update in that case, otherwise use a lock. */
2648 for (c
= clauses
; c
&& count
< 2; c
= OMP_CLAUSE_CHAIN (c
))
2649 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_REDUCTION
)
2651 if (OMP_CLAUSE_REDUCTION_PLACEHOLDER (c
))
2653 /* Never use OMP_ATOMIC for array reductions. */
2663 for (c
= clauses
; c
; c
= OMP_CLAUSE_CHAIN (c
))
2665 tree var
, ref
, new_var
;
2666 enum tree_code code
;
2667 location_t clause_loc
= OMP_CLAUSE_LOCATION (c
);
2669 if (OMP_CLAUSE_CODE (c
) != OMP_CLAUSE_REDUCTION
)
2672 var
= OMP_CLAUSE_DECL (c
);
2673 new_var
= lookup_decl (var
, ctx
);
2674 if (is_reference (var
))
2675 new_var
= build_simple_mem_ref_loc (clause_loc
, new_var
);
2676 ref
= build_outer_var_ref (var
, ctx
);
2677 code
= OMP_CLAUSE_REDUCTION_CODE (c
);
2679 /* reduction(-:var) sums up the partial results, so it acts
2680 identically to reduction(+:var). */
2681 if (code
== MINUS_EXPR
)
2686 tree addr
= build_fold_addr_expr_loc (clause_loc
, ref
);
2688 addr
= save_expr (addr
);
2689 ref
= build1 (INDIRECT_REF
, TREE_TYPE (TREE_TYPE (addr
)), addr
);
2690 x
= fold_build2_loc (clause_loc
, code
, TREE_TYPE (ref
), ref
, new_var
);
2691 x
= build2 (OMP_ATOMIC
, void_type_node
, addr
, x
);
2692 gimplify_and_add (x
, stmt_seqp
);
2696 if (OMP_CLAUSE_REDUCTION_PLACEHOLDER (c
))
2698 tree placeholder
= OMP_CLAUSE_REDUCTION_PLACEHOLDER (c
);
2700 if (is_reference (var
))
2701 ref
= build_fold_addr_expr_loc (clause_loc
, ref
);
2702 SET_DECL_VALUE_EXPR (placeholder
, ref
);
2703 DECL_HAS_VALUE_EXPR_P (placeholder
) = 1;
2704 lower_omp (&OMP_CLAUSE_REDUCTION_GIMPLE_MERGE (c
), ctx
);
2705 gimple_seq_add_seq (&sub_seq
, OMP_CLAUSE_REDUCTION_GIMPLE_MERGE (c
));
2706 OMP_CLAUSE_REDUCTION_GIMPLE_MERGE (c
) = NULL
;
2707 OMP_CLAUSE_REDUCTION_PLACEHOLDER (c
) = NULL
;
2711 x
= build2 (code
, TREE_TYPE (ref
), ref
, new_var
);
2712 ref
= build_outer_var_ref (var
, ctx
);
2713 gimplify_assign (ref
, x
, &sub_seq
);
2717 stmt
= gimple_build_call (builtin_decl_explicit (BUILT_IN_GOMP_ATOMIC_START
),
2719 gimple_seq_add_stmt (stmt_seqp
, stmt
);
2721 gimple_seq_add_seq (stmt_seqp
, sub_seq
);
2723 stmt
= gimple_build_call (builtin_decl_explicit (BUILT_IN_GOMP_ATOMIC_END
),
2725 gimple_seq_add_stmt (stmt_seqp
, stmt
);
2729 /* Generate code to implement the COPYPRIVATE clauses. */
2732 lower_copyprivate_clauses (tree clauses
, gimple_seq
*slist
, gimple_seq
*rlist
,
2737 for (c
= clauses
; c
; c
= OMP_CLAUSE_CHAIN (c
))
2739 tree var
, new_var
, ref
, x
;
2741 location_t clause_loc
= OMP_CLAUSE_LOCATION (c
);
2743 if (OMP_CLAUSE_CODE (c
) != OMP_CLAUSE_COPYPRIVATE
)
2746 var
= OMP_CLAUSE_DECL (c
);
2747 by_ref
= use_pointer_for_field (var
, NULL
);
2749 ref
= build_sender_ref (var
, ctx
);
2750 x
= new_var
= lookup_decl_in_outer_ctx (var
, ctx
);
2753 x
= build_fold_addr_expr_loc (clause_loc
, new_var
);
2754 x
= fold_convert_loc (clause_loc
, TREE_TYPE (ref
), x
);
2756 gimplify_assign (ref
, x
, slist
);
2758 ref
= build_receiver_ref (var
, false, ctx
);
2761 ref
= fold_convert_loc (clause_loc
,
2762 build_pointer_type (TREE_TYPE (new_var
)),
2764 ref
= build_fold_indirect_ref_loc (clause_loc
, ref
);
2766 if (is_reference (var
))
2768 ref
= fold_convert_loc (clause_loc
, TREE_TYPE (new_var
), ref
);
2769 ref
= build_simple_mem_ref_loc (clause_loc
, ref
);
2770 new_var
= build_simple_mem_ref_loc (clause_loc
, new_var
);
2772 x
= lang_hooks
.decls
.omp_clause_assign_op (c
, new_var
, ref
);
2773 gimplify_and_add (x
, rlist
);
2778 /* Generate code to implement the clauses, FIRSTPRIVATE, COPYIN, LASTPRIVATE,
2779 and REDUCTION from the sender (aka parent) side. */
2782 lower_send_clauses (tree clauses
, gimple_seq
*ilist
, gimple_seq
*olist
,
2787 for (c
= clauses
; c
; c
= OMP_CLAUSE_CHAIN (c
))
2789 tree val
, ref
, x
, var
;
2790 bool by_ref
, do_in
= false, do_out
= false;
2791 location_t clause_loc
= OMP_CLAUSE_LOCATION (c
);
2793 switch (OMP_CLAUSE_CODE (c
))
2795 case OMP_CLAUSE_PRIVATE
:
2796 if (OMP_CLAUSE_PRIVATE_OUTER_REF (c
))
2799 case OMP_CLAUSE_FIRSTPRIVATE
:
2800 case OMP_CLAUSE_COPYIN
:
2801 case OMP_CLAUSE_LASTPRIVATE
:
2802 case OMP_CLAUSE_REDUCTION
:
2808 val
= OMP_CLAUSE_DECL (c
);
2809 var
= lookup_decl_in_outer_ctx (val
, ctx
);
2811 if (OMP_CLAUSE_CODE (c
) != OMP_CLAUSE_COPYIN
2812 && is_global_var (var
))
2814 if (is_variable_sized (val
))
2816 by_ref
= use_pointer_for_field (val
, NULL
);
2818 switch (OMP_CLAUSE_CODE (c
))
2820 case OMP_CLAUSE_PRIVATE
:
2821 case OMP_CLAUSE_FIRSTPRIVATE
:
2822 case OMP_CLAUSE_COPYIN
:
2826 case OMP_CLAUSE_LASTPRIVATE
:
2827 if (by_ref
|| is_reference (val
))
2829 if (OMP_CLAUSE_LASTPRIVATE_FIRSTPRIVATE (c
))
2836 if (lang_hooks
.decls
.omp_private_outer_ref (val
))
2841 case OMP_CLAUSE_REDUCTION
:
2843 do_out
= !(by_ref
|| is_reference (val
));
2852 ref
= build_sender_ref (val
, ctx
);
2853 x
= by_ref
? build_fold_addr_expr_loc (clause_loc
, var
) : var
;
2854 gimplify_assign (ref
, x
, ilist
);
2855 if (is_task_ctx (ctx
))
2856 DECL_ABSTRACT_ORIGIN (TREE_OPERAND (ref
, 1)) = NULL
;
2861 ref
= build_sender_ref (val
, ctx
);
2862 gimplify_assign (var
, ref
, olist
);
2867 /* Generate code to implement SHARED from the sender (aka parent)
2868 side. This is trickier, since GIMPLE_OMP_PARALLEL_CLAUSES doesn't
2869 list things that got automatically shared. */
2872 lower_send_shared_vars (gimple_seq
*ilist
, gimple_seq
*olist
, omp_context
*ctx
)
2874 tree var
, ovar
, nvar
, f
, x
, record_type
;
2876 if (ctx
->record_type
== NULL
)
2879 record_type
= ctx
->srecord_type
? ctx
->srecord_type
: ctx
->record_type
;
2880 for (f
= TYPE_FIELDS (record_type
); f
; f
= DECL_CHAIN (f
))
2882 ovar
= DECL_ABSTRACT_ORIGIN (f
);
2883 nvar
= maybe_lookup_decl (ovar
, ctx
);
2884 if (!nvar
|| !DECL_HAS_VALUE_EXPR_P (nvar
))
2887 /* If CTX is a nested parallel directive. Find the immediately
2888 enclosing parallel or workshare construct that contains a
2889 mapping for OVAR. */
2890 var
= lookup_decl_in_outer_ctx (ovar
, ctx
);
2892 if (use_pointer_for_field (ovar
, ctx
))
2894 x
= build_sender_ref (ovar
, ctx
);
2895 var
= build_fold_addr_expr (var
);
2896 gimplify_assign (x
, var
, ilist
);
2900 x
= build_sender_ref (ovar
, ctx
);
2901 gimplify_assign (x
, var
, ilist
);
2903 if (!TREE_READONLY (var
)
2904 /* We don't need to receive a new reference to a result
2905 or parm decl. In fact we may not store to it as we will
2906 invalidate any pending RSO and generate wrong gimple
2908 && !((TREE_CODE (var
) == RESULT_DECL
2909 || TREE_CODE (var
) == PARM_DECL
)
2910 && DECL_BY_REFERENCE (var
)))
2912 x
= build_sender_ref (ovar
, ctx
);
2913 gimplify_assign (var
, x
, olist
);
2920 /* A convenience function to build an empty GIMPLE_COND with just the
2924 gimple_build_cond_empty (tree cond
)
2926 enum tree_code pred_code
;
2929 gimple_cond_get_ops_from_tree (cond
, &pred_code
, &lhs
, &rhs
);
2930 return gimple_build_cond (pred_code
, lhs
, rhs
, NULL_TREE
, NULL_TREE
);
2934 /* Build the function calls to GOMP_parallel_start etc to actually
2935 generate the parallel operation. REGION is the parallel region
2936 being expanded. BB is the block where to insert the code. WS_ARGS
2937 will be set if this is a call to a combined parallel+workshare
2938 construct, it contains the list of additional arguments needed by
2939 the workshare construct. */
2942 expand_parallel_call (struct omp_region
*region
, basic_block bb
,
2943 gimple entry_stmt
, VEC(tree
,gc
) *ws_args
)
2945 tree t
, t1
, t2
, val
, cond
, c
, clauses
;
2946 gimple_stmt_iterator gsi
;
2948 enum built_in_function start_ix
;
2950 location_t clause_loc
;
2953 clauses
= gimple_omp_parallel_clauses (entry_stmt
);
2955 /* Determine what flavor of GOMP_parallel_start we will be
2957 start_ix
= BUILT_IN_GOMP_PARALLEL_START
;
2958 if (is_combined_parallel (region
))
2960 switch (region
->inner
->type
)
2962 case GIMPLE_OMP_FOR
:
2963 gcc_assert (region
->inner
->sched_kind
!= OMP_CLAUSE_SCHEDULE_AUTO
);
2964 start_ix2
= ((int)BUILT_IN_GOMP_PARALLEL_LOOP_STATIC_START
2965 + (region
->inner
->sched_kind
2966 == OMP_CLAUSE_SCHEDULE_RUNTIME
2967 ? 3 : region
->inner
->sched_kind
));
2968 start_ix
= (enum built_in_function
)start_ix2
;
2970 case GIMPLE_OMP_SECTIONS
:
2971 start_ix
= BUILT_IN_GOMP_PARALLEL_SECTIONS_START
;
2978 /* By default, the value of NUM_THREADS is zero (selected at run time)
2979 and there is no conditional. */
2981 val
= build_int_cst (unsigned_type_node
, 0);
2983 c
= find_omp_clause (clauses
, OMP_CLAUSE_IF
);
2985 cond
= OMP_CLAUSE_IF_EXPR (c
);
2987 c
= find_omp_clause (clauses
, OMP_CLAUSE_NUM_THREADS
);
2990 val
= OMP_CLAUSE_NUM_THREADS_EXPR (c
);
2991 clause_loc
= OMP_CLAUSE_LOCATION (c
);
2994 clause_loc
= gimple_location (entry_stmt
);
2996 /* Ensure 'val' is of the correct type. */
2997 val
= fold_convert_loc (clause_loc
, unsigned_type_node
, val
);
2999 /* If we found the clause 'if (cond)', build either
3000 (cond != 0) or (cond ? val : 1u). */
3003 gimple_stmt_iterator gsi
;
3005 cond
= gimple_boolify (cond
);
3007 if (integer_zerop (val
))
3008 val
= fold_build2_loc (clause_loc
,
3009 EQ_EXPR
, unsigned_type_node
, cond
,
3010 build_int_cst (TREE_TYPE (cond
), 0));
3013 basic_block cond_bb
, then_bb
, else_bb
;
3014 edge e
, e_then
, e_else
;
3015 tree tmp_then
, tmp_else
, tmp_join
, tmp_var
;
3017 tmp_var
= create_tmp_var (TREE_TYPE (val
), NULL
);
3018 if (gimple_in_ssa_p (cfun
))
3020 tmp_then
= make_ssa_name (tmp_var
, NULL
);
3021 tmp_else
= make_ssa_name (tmp_var
, NULL
);
3022 tmp_join
= make_ssa_name (tmp_var
, NULL
);
3031 e
= split_block (bb
, NULL
);
3036 then_bb
= create_empty_bb (cond_bb
);
3037 else_bb
= create_empty_bb (then_bb
);
3038 set_immediate_dominator (CDI_DOMINATORS
, then_bb
, cond_bb
);
3039 set_immediate_dominator (CDI_DOMINATORS
, else_bb
, cond_bb
);
3041 stmt
= gimple_build_cond_empty (cond
);
3042 gsi
= gsi_start_bb (cond_bb
);
3043 gsi_insert_after (&gsi
, stmt
, GSI_CONTINUE_LINKING
);
3045 gsi
= gsi_start_bb (then_bb
);
3046 stmt
= gimple_build_assign (tmp_then
, val
);
3047 gsi_insert_after (&gsi
, stmt
, GSI_CONTINUE_LINKING
);
3049 gsi
= gsi_start_bb (else_bb
);
3050 stmt
= gimple_build_assign
3051 (tmp_else
, build_int_cst (unsigned_type_node
, 1));
3052 gsi_insert_after (&gsi
, stmt
, GSI_CONTINUE_LINKING
);
3054 make_edge (cond_bb
, then_bb
, EDGE_TRUE_VALUE
);
3055 make_edge (cond_bb
, else_bb
, EDGE_FALSE_VALUE
);
3056 e_then
= make_edge (then_bb
, bb
, EDGE_FALLTHRU
);
3057 e_else
= make_edge (else_bb
, bb
, EDGE_FALLTHRU
);
3059 if (gimple_in_ssa_p (cfun
))
3061 gimple phi
= create_phi_node (tmp_join
, bb
);
3062 SSA_NAME_DEF_STMT (tmp_join
) = phi
;
3063 add_phi_arg (phi
, tmp_then
, e_then
, UNKNOWN_LOCATION
);
3064 add_phi_arg (phi
, tmp_else
, e_else
, UNKNOWN_LOCATION
);
3070 gsi
= gsi_start_bb (bb
);
3071 val
= force_gimple_operand_gsi (&gsi
, val
, true, NULL_TREE
,
3072 false, GSI_CONTINUE_LINKING
);
3075 gsi
= gsi_last_bb (bb
);
3076 t
= gimple_omp_parallel_data_arg (entry_stmt
);
3078 t1
= null_pointer_node
;
3080 t1
= build_fold_addr_expr (t
);
3081 t2
= build_fold_addr_expr (gimple_omp_parallel_child_fn (entry_stmt
));
3083 args
= VEC_alloc (tree
, gc
, 3 + VEC_length (tree
, ws_args
));
3084 VEC_quick_push (tree
, args
, t2
);
3085 VEC_quick_push (tree
, args
, t1
);
3086 VEC_quick_push (tree
, args
, val
);
3087 VEC_splice (tree
, args
, ws_args
);
3089 t
= build_call_expr_loc_vec (UNKNOWN_LOCATION
,
3090 builtin_decl_explicit (start_ix
), args
);
3092 force_gimple_operand_gsi (&gsi
, t
, true, NULL_TREE
,
3093 false, GSI_CONTINUE_LINKING
);
3095 t
= gimple_omp_parallel_data_arg (entry_stmt
);
3097 t
= null_pointer_node
;
3099 t
= build_fold_addr_expr (t
);
3100 t
= build_call_expr_loc (gimple_location (entry_stmt
),
3101 gimple_omp_parallel_child_fn (entry_stmt
), 1, t
);
3102 force_gimple_operand_gsi (&gsi
, t
, true, NULL_TREE
,
3103 false, GSI_CONTINUE_LINKING
);
3105 t
= build_call_expr_loc (gimple_location (entry_stmt
),
3106 builtin_decl_explicit (BUILT_IN_GOMP_PARALLEL_END
),
3108 force_gimple_operand_gsi (&gsi
, t
, true, NULL_TREE
,
3109 false, GSI_CONTINUE_LINKING
);
3113 /* Build the function call to GOMP_task to actually
3114 generate the task operation. BB is the block where to insert the code. */
3117 expand_task_call (basic_block bb
, gimple entry_stmt
)
3119 tree t
, t1
, t2
, t3
, flags
, cond
, c
, c2
, clauses
;
3120 gimple_stmt_iterator gsi
;
3121 location_t loc
= gimple_location (entry_stmt
);
3123 clauses
= gimple_omp_task_clauses (entry_stmt
);
3125 c
= find_omp_clause (clauses
, OMP_CLAUSE_IF
);
3127 cond
= gimple_boolify (OMP_CLAUSE_IF_EXPR (c
));
3129 cond
= boolean_true_node
;
3131 c
= find_omp_clause (clauses
, OMP_CLAUSE_UNTIED
);
3132 c2
= find_omp_clause (clauses
, OMP_CLAUSE_MERGEABLE
);
3133 flags
= build_int_cst (unsigned_type_node
,
3134 (c
? 1 : 0) + (c2
? 4 : 0));
3136 c
= find_omp_clause (clauses
, OMP_CLAUSE_FINAL
);
3139 c
= gimple_boolify (OMP_CLAUSE_FINAL_EXPR (c
));
3140 c
= fold_build3_loc (loc
, COND_EXPR
, unsigned_type_node
, c
,
3141 build_int_cst (unsigned_type_node
, 2),
3142 build_int_cst (unsigned_type_node
, 0));
3143 flags
= fold_build2_loc (loc
, PLUS_EXPR
, unsigned_type_node
, flags
, c
);
3146 gsi
= gsi_last_bb (bb
);
3147 t
= gimple_omp_task_data_arg (entry_stmt
);
3149 t2
= null_pointer_node
;
3151 t2
= build_fold_addr_expr_loc (loc
, t
);
3152 t1
= build_fold_addr_expr_loc (loc
, gimple_omp_task_child_fn (entry_stmt
));
3153 t
= gimple_omp_task_copy_fn (entry_stmt
);
3155 t3
= null_pointer_node
;
3157 t3
= build_fold_addr_expr_loc (loc
, t
);
3159 t
= build_call_expr (builtin_decl_explicit (BUILT_IN_GOMP_TASK
),
3161 gimple_omp_task_arg_size (entry_stmt
),
3162 gimple_omp_task_arg_align (entry_stmt
), cond
, flags
);
3164 force_gimple_operand_gsi (&gsi
, t
, true, NULL_TREE
,
3165 false, GSI_CONTINUE_LINKING
);
3169 /* If exceptions are enabled, wrap the statements in BODY in a MUST_NOT_THROW
3170 catch handler and return it. This prevents programs from violating the
3171 structured block semantics with throws. */
3174 maybe_catch_exception (gimple_seq body
)
3179 if (!flag_exceptions
)
3182 if (lang_hooks
.eh_protect_cleanup_actions
!= NULL
)
3183 decl
= lang_hooks
.eh_protect_cleanup_actions ();
3185 decl
= builtin_decl_explicit (BUILT_IN_TRAP
);
3187 g
= gimple_build_eh_must_not_throw (decl
);
3188 g
= gimple_build_try (body
, gimple_seq_alloc_with_stmt (g
),
3191 return gimple_seq_alloc_with_stmt (g
);
3194 /* Chain all the DECLs in LIST by their TREE_CHAIN fields. */
3197 vec2chain (VEC(tree
,gc
) *v
)
3199 tree chain
= NULL_TREE
, t
;
3202 FOR_EACH_VEC_ELT_REVERSE (tree
, v
, ix
, t
)
3204 DECL_CHAIN (t
) = chain
;
3212 /* Remove barriers in REGION->EXIT's block. Note that this is only
3213 valid for GIMPLE_OMP_PARALLEL regions. Since the end of a parallel region
3214 is an implicit barrier, any workshare inside the GIMPLE_OMP_PARALLEL that
3215 left a barrier at the end of the GIMPLE_OMP_PARALLEL region can now be
3219 remove_exit_barrier (struct omp_region
*region
)
3221 gimple_stmt_iterator gsi
;
3222 basic_block exit_bb
;
3226 int any_addressable_vars
= -1;
3228 exit_bb
= region
->exit
;
3230 /* If the parallel region doesn't return, we don't have REGION->EXIT
3235 /* The last insn in the block will be the parallel's GIMPLE_OMP_RETURN. The
3236 workshare's GIMPLE_OMP_RETURN will be in a preceding block. The kinds of
3237 statements that can appear in between are extremely limited -- no
3238 memory operations at all. Here, we allow nothing at all, so the
3239 only thing we allow to precede this GIMPLE_OMP_RETURN is a label. */
3240 gsi
= gsi_last_bb (exit_bb
);
3241 gcc_assert (gimple_code (gsi_stmt (gsi
)) == GIMPLE_OMP_RETURN
);
3243 if (!gsi_end_p (gsi
) && gimple_code (gsi_stmt (gsi
)) != GIMPLE_LABEL
)
3246 FOR_EACH_EDGE (e
, ei
, exit_bb
->preds
)
3248 gsi
= gsi_last_bb (e
->src
);
3249 if (gsi_end_p (gsi
))
3251 stmt
= gsi_stmt (gsi
);
3252 if (gimple_code (stmt
) == GIMPLE_OMP_RETURN
3253 && !gimple_omp_return_nowait_p (stmt
))
3255 /* OpenMP 3.0 tasks unfortunately prevent this optimization
3256 in many cases. If there could be tasks queued, the barrier
3257 might be needed to let the tasks run before some local
3258 variable of the parallel that the task uses as shared
3259 runs out of scope. The task can be spawned either
3260 from within current function (this would be easy to check)
3261 or from some function it calls and gets passed an address
3262 of such a variable. */
3263 if (any_addressable_vars
< 0)
3265 gimple parallel_stmt
= last_stmt (region
->entry
);
3266 tree child_fun
= gimple_omp_parallel_child_fn (parallel_stmt
);
3267 tree local_decls
, block
, decl
;
3270 any_addressable_vars
= 0;
3271 FOR_EACH_LOCAL_DECL (DECL_STRUCT_FUNCTION (child_fun
), ix
, decl
)
3272 if (TREE_ADDRESSABLE (decl
))
3274 any_addressable_vars
= 1;
3277 for (block
= gimple_block (stmt
);
3278 !any_addressable_vars
3280 && TREE_CODE (block
) == BLOCK
;
3281 block
= BLOCK_SUPERCONTEXT (block
))
3283 for (local_decls
= BLOCK_VARS (block
);
3285 local_decls
= DECL_CHAIN (local_decls
))
3286 if (TREE_ADDRESSABLE (local_decls
))
3288 any_addressable_vars
= 1;
3291 if (block
== gimple_block (parallel_stmt
))
3295 if (!any_addressable_vars
)
3296 gimple_omp_return_set_nowait (stmt
);
3302 remove_exit_barriers (struct omp_region
*region
)
3304 if (region
->type
== GIMPLE_OMP_PARALLEL
)
3305 remove_exit_barrier (region
);
3309 region
= region
->inner
;
3310 remove_exit_barriers (region
);
3311 while (region
->next
)
3313 region
= region
->next
;
3314 remove_exit_barriers (region
);
3319 /* Optimize omp_get_thread_num () and omp_get_num_threads ()
3320 calls. These can't be declared as const functions, but
3321 within one parallel body they are constant, so they can be
3322 transformed there into __builtin_omp_get_{thread_num,num_threads} ()
3323 which are declared const. Similarly for task body, except
3324 that in untied task omp_get_thread_num () can change at any task
3325 scheduling point. */
3328 optimize_omp_library_calls (gimple entry_stmt
)
3331 gimple_stmt_iterator gsi
;
3332 tree thr_num_tree
= builtin_decl_explicit (BUILT_IN_OMP_GET_THREAD_NUM
);
3333 tree thr_num_id
= DECL_ASSEMBLER_NAME (thr_num_tree
);
3334 tree num_thr_tree
= builtin_decl_explicit (BUILT_IN_OMP_GET_NUM_THREADS
);
3335 tree num_thr_id
= DECL_ASSEMBLER_NAME (num_thr_tree
);
3336 bool untied_task
= (gimple_code (entry_stmt
) == GIMPLE_OMP_TASK
3337 && find_omp_clause (gimple_omp_task_clauses (entry_stmt
),
3338 OMP_CLAUSE_UNTIED
) != NULL
);
3341 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
3343 gimple call
= gsi_stmt (gsi
);
3346 if (is_gimple_call (call
)
3347 && (decl
= gimple_call_fndecl (call
))
3348 && DECL_EXTERNAL (decl
)
3349 && TREE_PUBLIC (decl
)
3350 && DECL_INITIAL (decl
) == NULL
)
3354 if (DECL_NAME (decl
) == thr_num_id
)
3356 /* In #pragma omp task untied omp_get_thread_num () can change
3357 during the execution of the task region. */
3360 built_in
= builtin_decl_explicit (BUILT_IN_OMP_GET_THREAD_NUM
);
3362 else if (DECL_NAME (decl
) == num_thr_id
)
3363 built_in
= builtin_decl_explicit (BUILT_IN_OMP_GET_NUM_THREADS
);
3367 if (DECL_ASSEMBLER_NAME (decl
) != DECL_ASSEMBLER_NAME (built_in
)
3368 || gimple_call_num_args (call
) != 0)
3371 if (flag_exceptions
&& !TREE_NOTHROW (decl
))
3374 if (TREE_CODE (TREE_TYPE (decl
)) != FUNCTION_TYPE
3375 || !types_compatible_p (TREE_TYPE (TREE_TYPE (decl
)),
3376 TREE_TYPE (TREE_TYPE (built_in
))))
3379 gimple_call_set_fndecl (call
, built_in
);
3384 /* Expand the OpenMP parallel or task directive starting at REGION. */
3387 expand_omp_taskreg (struct omp_region
*region
)
3389 basic_block entry_bb
, exit_bb
, new_bb
;
3390 struct function
*child_cfun
;
3391 tree child_fn
, block
, t
;
3393 gimple_stmt_iterator gsi
;
3394 gimple entry_stmt
, stmt
;
3396 VEC(tree
,gc
) *ws_args
;
3398 entry_stmt
= last_stmt (region
->entry
);
3399 child_fn
= gimple_omp_taskreg_child_fn (entry_stmt
);
3400 child_cfun
= DECL_STRUCT_FUNCTION (child_fn
);
3402 entry_bb
= region
->entry
;
3403 exit_bb
= region
->exit
;
3405 if (is_combined_parallel (region
))
3406 ws_args
= region
->ws_args
;
3410 if (child_cfun
->cfg
)
3412 /* Due to inlining, it may happen that we have already outlined
3413 the region, in which case all we need to do is make the
3414 sub-graph unreachable and emit the parallel call. */
3415 edge entry_succ_e
, exit_succ_e
;
3416 gimple_stmt_iterator gsi
;
3418 entry_succ_e
= single_succ_edge (entry_bb
);
3420 gsi
= gsi_last_bb (entry_bb
);
3421 gcc_assert (gimple_code (gsi_stmt (gsi
)) == GIMPLE_OMP_PARALLEL
3422 || gimple_code (gsi_stmt (gsi
)) == GIMPLE_OMP_TASK
);
3423 gsi_remove (&gsi
, true);
3428 exit_succ_e
= single_succ_edge (exit_bb
);
3429 make_edge (new_bb
, exit_succ_e
->dest
, EDGE_FALLTHRU
);
3431 remove_edge_and_dominated_blocks (entry_succ_e
);
3435 unsigned srcidx
, dstidx
, num
;
3437 /* If the parallel region needs data sent from the parent
3438 function, then the very first statement (except possible
3439 tree profile counter updates) of the parallel body
3440 is a copy assignment .OMP_DATA_I = &.OMP_DATA_O. Since
3441 &.OMP_DATA_O is passed as an argument to the child function,
3442 we need to replace it with the argument as seen by the child
3445 In most cases, this will end up being the identity assignment
3446 .OMP_DATA_I = .OMP_DATA_I. However, if the parallel body had
3447 a function call that has been inlined, the original PARM_DECL
3448 .OMP_DATA_I may have been converted into a different local
3449 variable. In which case, we need to keep the assignment. */
3450 if (gimple_omp_taskreg_data_arg (entry_stmt
))
3452 basic_block entry_succ_bb
= single_succ (entry_bb
);
3453 gimple_stmt_iterator gsi
;
3455 gimple parcopy_stmt
= NULL
;
3457 for (gsi
= gsi_start_bb (entry_succ_bb
); ; gsi_next (&gsi
))
3461 gcc_assert (!gsi_end_p (gsi
));
3462 stmt
= gsi_stmt (gsi
);
3463 if (gimple_code (stmt
) != GIMPLE_ASSIGN
)
3466 if (gimple_num_ops (stmt
) == 2)
3468 tree arg
= gimple_assign_rhs1 (stmt
);
3470 /* We're ignore the subcode because we're
3471 effectively doing a STRIP_NOPS. */
3473 if (TREE_CODE (arg
) == ADDR_EXPR
3474 && TREE_OPERAND (arg
, 0)
3475 == gimple_omp_taskreg_data_arg (entry_stmt
))
3477 parcopy_stmt
= stmt
;
3483 gcc_assert (parcopy_stmt
!= NULL
);
3484 arg
= DECL_ARGUMENTS (child_fn
);
3486 if (!gimple_in_ssa_p (cfun
))
3488 if (gimple_assign_lhs (parcopy_stmt
) == arg
)
3489 gsi_remove (&gsi
, true);
3492 /* ?? Is setting the subcode really necessary ?? */
3493 gimple_omp_set_subcode (parcopy_stmt
, TREE_CODE (arg
));
3494 gimple_assign_set_rhs1 (parcopy_stmt
, arg
);
3499 /* If we are in ssa form, we must load the value from the default
3500 definition of the argument. That should not be defined now,
3501 since the argument is not used uninitialized. */
3502 gcc_assert (ssa_default_def (cfun
, arg
) == NULL
);
3503 narg
= make_ssa_name (arg
, gimple_build_nop ());
3504 set_ssa_default_def (cfun
, arg
, narg
);
3505 /* ?? Is setting the subcode really necessary ?? */
3506 gimple_omp_set_subcode (parcopy_stmt
, TREE_CODE (narg
));
3507 gimple_assign_set_rhs1 (parcopy_stmt
, narg
);
3508 update_stmt (parcopy_stmt
);
3512 /* Declare local variables needed in CHILD_CFUN. */
3513 block
= DECL_INITIAL (child_fn
);
3514 BLOCK_VARS (block
) = vec2chain (child_cfun
->local_decls
);
3515 /* The gimplifier could record temporaries in parallel/task block
3516 rather than in containing function's local_decls chain,
3517 which would mean cgraph missed finalizing them. Do it now. */
3518 for (t
= BLOCK_VARS (block
); t
; t
= DECL_CHAIN (t
))
3519 if (TREE_CODE (t
) == VAR_DECL
3521 && !DECL_EXTERNAL (t
))
3522 varpool_finalize_decl (t
);
3523 DECL_SAVED_TREE (child_fn
) = NULL
;
3524 /* We'll create a CFG for child_fn, so no gimple body is needed. */
3525 gimple_set_body (child_fn
, NULL
);
3526 TREE_USED (block
) = 1;
3528 /* Reset DECL_CONTEXT on function arguments. */
3529 for (t
= DECL_ARGUMENTS (child_fn
); t
; t
= DECL_CHAIN (t
))
3530 DECL_CONTEXT (t
) = child_fn
;
3532 /* Split ENTRY_BB at GIMPLE_OMP_PARALLEL or GIMPLE_OMP_TASK,
3533 so that it can be moved to the child function. */
3534 gsi
= gsi_last_bb (entry_bb
);
3535 stmt
= gsi_stmt (gsi
);
3536 gcc_assert (stmt
&& (gimple_code (stmt
) == GIMPLE_OMP_PARALLEL
3537 || gimple_code (stmt
) == GIMPLE_OMP_TASK
));
3538 gsi_remove (&gsi
, true);
3539 e
= split_block (entry_bb
, stmt
);
3541 single_succ_edge (entry_bb
)->flags
= EDGE_FALLTHRU
;
3543 /* Convert GIMPLE_OMP_RETURN into a RETURN_EXPR. */
3546 gsi
= gsi_last_bb (exit_bb
);
3547 gcc_assert (!gsi_end_p (gsi
)
3548 && gimple_code (gsi_stmt (gsi
)) == GIMPLE_OMP_RETURN
);
3549 stmt
= gimple_build_return (NULL
);
3550 gsi_insert_after (&gsi
, stmt
, GSI_SAME_STMT
);
3551 gsi_remove (&gsi
, true);
3554 /* Move the parallel region into CHILD_CFUN. */
3556 if (gimple_in_ssa_p (cfun
))
3558 init_tree_ssa (child_cfun
);
3559 init_ssa_operands (child_cfun
);
3560 child_cfun
->gimple_df
->in_ssa_p
= true;
3564 block
= gimple_block (entry_stmt
);
3566 new_bb
= move_sese_region_to_fn (child_cfun
, entry_bb
, exit_bb
, block
);
3568 single_succ_edge (new_bb
)->flags
= EDGE_FALLTHRU
;
3570 /* Remove non-local VAR_DECLs from child_cfun->local_decls list. */
3571 num
= VEC_length (tree
, child_cfun
->local_decls
);
3572 for (srcidx
= 0, dstidx
= 0; srcidx
< num
; srcidx
++)
3574 t
= VEC_index (tree
, child_cfun
->local_decls
, srcidx
);
3575 if (DECL_CONTEXT (t
) == cfun
->decl
)
3577 if (srcidx
!= dstidx
)
3578 VEC_replace (tree
, child_cfun
->local_decls
, dstidx
, t
);
3582 VEC_truncate (tree
, child_cfun
->local_decls
, dstidx
);
3584 /* Inform the callgraph about the new function. */
3585 DECL_STRUCT_FUNCTION (child_fn
)->curr_properties
3586 = cfun
->curr_properties
& ~PROP_loops
;
3587 cgraph_add_new_function (child_fn
, true);
3589 /* Fix the callgraph edges for child_cfun. Those for cfun will be
3590 fixed in a following pass. */
3591 push_cfun (child_cfun
);
3592 save_current
= current_function_decl
;
3593 current_function_decl
= child_fn
;
3595 optimize_omp_library_calls (entry_stmt
);
3596 rebuild_cgraph_edges ();
3598 /* Some EH regions might become dead, see PR34608. If
3599 pass_cleanup_cfg isn't the first pass to happen with the
3600 new child, these dead EH edges might cause problems.
3601 Clean them up now. */
3602 if (flag_exceptions
)
3605 bool changed
= false;
3608 changed
|= gimple_purge_dead_eh_edges (bb
);
3610 cleanup_tree_cfg ();
3612 if (gimple_in_ssa_p (cfun
))
3613 update_ssa (TODO_update_ssa
);
3614 current_function_decl
= save_current
;
3618 /* Emit a library call to launch the children threads. */
3619 if (gimple_code (entry_stmt
) == GIMPLE_OMP_PARALLEL
)
3620 expand_parallel_call (region
, new_bb
, entry_stmt
, ws_args
);
3622 expand_task_call (new_bb
, entry_stmt
);
3623 if (gimple_in_ssa_p (cfun
))
3624 update_ssa (TODO_update_ssa_only_virtuals
);
3628 /* A subroutine of expand_omp_for. Generate code for a parallel
3629 loop with any schedule. Given parameters:
3631 for (V = N1; V cond N2; V += STEP) BODY;
3633 where COND is "<" or ">", we generate pseudocode
3635 more = GOMP_loop_foo_start (N1, N2, STEP, CHUNK, &istart0, &iend0);
3636 if (more) goto L0; else goto L3;
3643 if (V cond iend) goto L1; else goto L2;
3645 if (GOMP_loop_foo_next (&istart0, &iend0)) goto L0; else goto L3;
3648 If this is a combined omp parallel loop, instead of the call to
3649 GOMP_loop_foo_start, we call GOMP_loop_foo_next.
3651 For collapsed loops, given parameters:
3653 for (V1 = N11; V1 cond1 N12; V1 += STEP1)
3654 for (V2 = N21; V2 cond2 N22; V2 += STEP2)
3655 for (V3 = N31; V3 cond3 N32; V3 += STEP3)
3658 we generate pseudocode
3664 count3 = (adj + N32 - N31) / STEP3;
3669 count2 = (adj + N22 - N21) / STEP2;
3674 count1 = (adj + N12 - N11) / STEP1;
3675 count = count1 * count2 * count3;
3676 more = GOMP_loop_foo_start (0, count, 1, CHUNK, &istart0, &iend0);
3677 if (more) goto L0; else goto L3;
3681 V3 = N31 + (T % count3) * STEP3;
3683 V2 = N21 + (T % count2) * STEP2;
3685 V1 = N11 + T * STEP1;
3690 if (V < iend) goto L10; else goto L2;
3693 if (V3 cond3 N32) goto L1; else goto L11;
3697 if (V2 cond2 N22) goto L1; else goto L12;
3703 if (GOMP_loop_foo_next (&istart0, &iend0)) goto L0; else goto L3;
3709 expand_omp_for_generic (struct omp_region
*region
,
3710 struct omp_for_data
*fd
,
3711 enum built_in_function start_fn
,
3712 enum built_in_function next_fn
)
3714 tree type
, istart0
, iend0
, iend
;
3715 tree t
, vmain
, vback
, bias
= NULL_TREE
;
3716 basic_block entry_bb
, cont_bb
, exit_bb
, l0_bb
, l1_bb
, collapse_bb
;
3717 basic_block l2_bb
= NULL
, l3_bb
= NULL
;
3718 gimple_stmt_iterator gsi
;
3720 bool in_combined_parallel
= is_combined_parallel (region
);
3721 bool broken_loop
= region
->cont
== NULL
;
3723 tree
*counts
= NULL
;
3726 gcc_assert (!broken_loop
|| !in_combined_parallel
);
3727 gcc_assert (fd
->iter_type
== long_integer_type_node
3728 || !in_combined_parallel
);
3730 type
= TREE_TYPE (fd
->loop
.v
);
3731 istart0
= create_tmp_var (fd
->iter_type
, ".istart0");
3732 iend0
= create_tmp_var (fd
->iter_type
, ".iend0");
3733 TREE_ADDRESSABLE (istart0
) = 1;
3734 TREE_ADDRESSABLE (iend0
) = 1;
3736 /* See if we need to bias by LLONG_MIN. */
3737 if (fd
->iter_type
== long_long_unsigned_type_node
3738 && TREE_CODE (type
) == INTEGER_TYPE
3739 && !TYPE_UNSIGNED (type
))
3743 if (fd
->loop
.cond_code
== LT_EXPR
)
3746 n2
= fold_build2 (PLUS_EXPR
, type
, fd
->loop
.n2
, fd
->loop
.step
);
3750 n1
= fold_build2 (MINUS_EXPR
, type
, fd
->loop
.n2
, fd
->loop
.step
);
3753 if (TREE_CODE (n1
) != INTEGER_CST
3754 || TREE_CODE (n2
) != INTEGER_CST
3755 || ((tree_int_cst_sgn (n1
) < 0) ^ (tree_int_cst_sgn (n2
) < 0)))
3756 bias
= fold_convert (fd
->iter_type
, TYPE_MIN_VALUE (type
));
3759 entry_bb
= region
->entry
;
3760 cont_bb
= region
->cont
;
3762 gcc_assert (EDGE_COUNT (entry_bb
->succs
) == 2);
3763 gcc_assert (broken_loop
3764 || BRANCH_EDGE (entry_bb
)->dest
== FALLTHRU_EDGE (cont_bb
)->dest
);
3765 l0_bb
= split_edge (FALLTHRU_EDGE (entry_bb
));
3766 l1_bb
= single_succ (l0_bb
);
3769 l2_bb
= create_empty_bb (cont_bb
);
3770 gcc_assert (BRANCH_EDGE (cont_bb
)->dest
== l1_bb
);
3771 gcc_assert (EDGE_COUNT (cont_bb
->succs
) == 2);
3775 l3_bb
= BRANCH_EDGE (entry_bb
)->dest
;
3776 exit_bb
= region
->exit
;
3778 gsi
= gsi_last_bb (entry_bb
);
3780 gcc_assert (gimple_code (gsi_stmt (gsi
)) == GIMPLE_OMP_FOR
);
3781 if (fd
->collapse
> 1)
3783 /* collapsed loops need work for expansion in SSA form. */
3784 gcc_assert (!gimple_in_ssa_p (cfun
));
3785 counts
= (tree
*) alloca (fd
->collapse
* sizeof (tree
));
3786 for (i
= 0; i
< fd
->collapse
; i
++)
3788 tree itype
= TREE_TYPE (fd
->loops
[i
].v
);
3790 if (POINTER_TYPE_P (itype
))
3791 itype
= signed_type_for (itype
);
3792 t
= build_int_cst (itype
, (fd
->loops
[i
].cond_code
== LT_EXPR
3794 t
= fold_build2 (PLUS_EXPR
, itype
,
3795 fold_convert (itype
, fd
->loops
[i
].step
), t
);
3796 t
= fold_build2 (PLUS_EXPR
, itype
, t
,
3797 fold_convert (itype
, fd
->loops
[i
].n2
));
3798 t
= fold_build2 (MINUS_EXPR
, itype
, t
,
3799 fold_convert (itype
, fd
->loops
[i
].n1
));
3800 if (TYPE_UNSIGNED (itype
) && fd
->loops
[i
].cond_code
== GT_EXPR
)
3801 t
= fold_build2 (TRUNC_DIV_EXPR
, itype
,
3802 fold_build1 (NEGATE_EXPR
, itype
, t
),
3803 fold_build1 (NEGATE_EXPR
, itype
,
3804 fold_convert (itype
,
3805 fd
->loops
[i
].step
)));
3807 t
= fold_build2 (TRUNC_DIV_EXPR
, itype
, t
,
3808 fold_convert (itype
, fd
->loops
[i
].step
));
3809 t
= fold_convert (type
, t
);
3810 if (TREE_CODE (t
) == INTEGER_CST
)
3814 counts
[i
] = create_tmp_reg (type
, ".count");
3815 t
= force_gimple_operand_gsi (&gsi
, t
, false, NULL_TREE
,
3816 true, GSI_SAME_STMT
);
3817 stmt
= gimple_build_assign (counts
[i
], t
);
3818 gsi_insert_before (&gsi
, stmt
, GSI_SAME_STMT
);
3820 if (SSA_VAR_P (fd
->loop
.n2
))
3826 t
= fold_build2 (MULT_EXPR
, type
, fd
->loop
.n2
, counts
[i
]);
3827 t
= force_gimple_operand_gsi (&gsi
, t
, false, NULL_TREE
,
3828 true, GSI_SAME_STMT
);
3830 stmt
= gimple_build_assign (fd
->loop
.n2
, t
);
3831 gsi_insert_before (&gsi
, stmt
, GSI_SAME_STMT
);
3835 if (in_combined_parallel
)
3837 /* In a combined parallel loop, emit a call to
3838 GOMP_loop_foo_next. */
3839 t
= build_call_expr (builtin_decl_explicit (next_fn
), 2,
3840 build_fold_addr_expr (istart0
),
3841 build_fold_addr_expr (iend0
));
3845 tree t0
, t1
, t2
, t3
, t4
;
3846 /* If this is not a combined parallel loop, emit a call to
3847 GOMP_loop_foo_start in ENTRY_BB. */
3848 t4
= build_fold_addr_expr (iend0
);
3849 t3
= build_fold_addr_expr (istart0
);
3850 t2
= fold_convert (fd
->iter_type
, fd
->loop
.step
);
3851 if (POINTER_TYPE_P (type
)
3852 && TYPE_PRECISION (type
) != TYPE_PRECISION (fd
->iter_type
))
3854 /* Avoid casting pointers to integer of a different size. */
3855 tree itype
= signed_type_for (type
);
3856 t1
= fold_convert (fd
->iter_type
, fold_convert (itype
, fd
->loop
.n2
));
3857 t0
= fold_convert (fd
->iter_type
, fold_convert (itype
, fd
->loop
.n1
));
3861 t1
= fold_convert (fd
->iter_type
, fd
->loop
.n2
);
3862 t0
= fold_convert (fd
->iter_type
, fd
->loop
.n1
);
3866 t1
= fold_build2 (PLUS_EXPR
, fd
->iter_type
, t1
, bias
);
3867 t0
= fold_build2 (PLUS_EXPR
, fd
->iter_type
, t0
, bias
);
3869 if (fd
->iter_type
== long_integer_type_node
)
3873 t
= fold_convert (fd
->iter_type
, fd
->chunk_size
);
3874 t
= build_call_expr (builtin_decl_explicit (start_fn
),
3875 6, t0
, t1
, t2
, t
, t3
, t4
);
3878 t
= build_call_expr (builtin_decl_explicit (start_fn
),
3879 5, t0
, t1
, t2
, t3
, t4
);
3887 /* The GOMP_loop_ull_*start functions have additional boolean
3888 argument, true for < loops and false for > loops.
3889 In Fortran, the C bool type can be different from
3890 boolean_type_node. */
3891 bfn_decl
= builtin_decl_explicit (start_fn
);
3892 c_bool_type
= TREE_TYPE (TREE_TYPE (bfn_decl
));
3893 t5
= build_int_cst (c_bool_type
,
3894 fd
->loop
.cond_code
== LT_EXPR
? 1 : 0);
3897 tree bfn_decl
= builtin_decl_explicit (start_fn
);
3898 t
= fold_convert (fd
->iter_type
, fd
->chunk_size
);
3899 t
= build_call_expr (bfn_decl
, 7, t5
, t0
, t1
, t2
, t
, t3
, t4
);
3902 t
= build_call_expr (builtin_decl_explicit (start_fn
),
3903 6, t5
, t0
, t1
, t2
, t3
, t4
);
3906 if (TREE_TYPE (t
) != boolean_type_node
)
3907 t
= fold_build2 (NE_EXPR
, boolean_type_node
,
3908 t
, build_int_cst (TREE_TYPE (t
), 0));
3909 t
= force_gimple_operand_gsi (&gsi
, t
, true, NULL_TREE
,
3910 true, GSI_SAME_STMT
);
3911 gsi_insert_after (&gsi
, gimple_build_cond_empty (t
), GSI_SAME_STMT
);
3913 /* Remove the GIMPLE_OMP_FOR statement. */
3914 gsi_remove (&gsi
, true);
3916 /* Iteration setup for sequential loop goes in L0_BB. */
3917 gsi
= gsi_start_bb (l0_bb
);
3920 t
= fold_build2 (MINUS_EXPR
, fd
->iter_type
, t
, bias
);
3921 if (POINTER_TYPE_P (type
))
3922 t
= fold_convert (signed_type_for (type
), t
);
3923 t
= fold_convert (type
, t
);
3924 t
= force_gimple_operand_gsi (&gsi
, t
, false, NULL_TREE
,
3925 false, GSI_CONTINUE_LINKING
);
3926 stmt
= gimple_build_assign (fd
->loop
.v
, t
);
3927 gsi_insert_after (&gsi
, stmt
, GSI_CONTINUE_LINKING
);
3931 t
= fold_build2 (MINUS_EXPR
, fd
->iter_type
, t
, bias
);
3932 if (POINTER_TYPE_P (type
))
3933 t
= fold_convert (signed_type_for (type
), t
);
3934 t
= fold_convert (type
, t
);
3935 iend
= force_gimple_operand_gsi (&gsi
, t
, true, NULL_TREE
,
3936 false, GSI_CONTINUE_LINKING
);
3937 if (fd
->collapse
> 1)
3939 tree tem
= create_tmp_reg (type
, ".tem");
3940 stmt
= gimple_build_assign (tem
, fd
->loop
.v
);
3941 gsi_insert_after (&gsi
, stmt
, GSI_CONTINUE_LINKING
);
3942 for (i
= fd
->collapse
- 1; i
>= 0; i
--)
3944 tree vtype
= TREE_TYPE (fd
->loops
[i
].v
), itype
;
3946 if (POINTER_TYPE_P (vtype
))
3947 itype
= signed_type_for (vtype
);
3948 t
= fold_build2 (TRUNC_MOD_EXPR
, type
, tem
, counts
[i
]);
3949 t
= fold_convert (itype
, t
);
3950 t
= fold_build2 (MULT_EXPR
, itype
, t
,
3951 fold_convert (itype
, fd
->loops
[i
].step
));
3952 if (POINTER_TYPE_P (vtype
))
3953 t
= fold_build_pointer_plus (fd
->loops
[i
].n1
, t
);
3955 t
= fold_build2 (PLUS_EXPR
, itype
, fd
->loops
[i
].n1
, t
);
3956 t
= force_gimple_operand_gsi (&gsi
, t
, false, NULL_TREE
,
3957 false, GSI_CONTINUE_LINKING
);
3958 stmt
= gimple_build_assign (fd
->loops
[i
].v
, t
);
3959 gsi_insert_after (&gsi
, stmt
, GSI_CONTINUE_LINKING
);
3962 t
= fold_build2 (TRUNC_DIV_EXPR
, type
, tem
, counts
[i
]);
3963 t
= force_gimple_operand_gsi (&gsi
, t
, false, NULL_TREE
,
3964 false, GSI_CONTINUE_LINKING
);
3965 stmt
= gimple_build_assign (tem
, t
);
3966 gsi_insert_after (&gsi
, stmt
, GSI_CONTINUE_LINKING
);
3973 /* Code to control the increment and predicate for the sequential
3974 loop goes in the CONT_BB. */
3975 gsi
= gsi_last_bb (cont_bb
);
3976 stmt
= gsi_stmt (gsi
);
3977 gcc_assert (gimple_code (stmt
) == GIMPLE_OMP_CONTINUE
);
3978 vmain
= gimple_omp_continue_control_use (stmt
);
3979 vback
= gimple_omp_continue_control_def (stmt
);
3981 if (POINTER_TYPE_P (type
))
3982 t
= fold_build_pointer_plus (vmain
, fd
->loop
.step
);
3984 t
= fold_build2 (PLUS_EXPR
, type
, vmain
, fd
->loop
.step
);
3985 t
= force_gimple_operand_gsi (&gsi
, t
, false, NULL_TREE
,
3986 true, GSI_SAME_STMT
);
3987 stmt
= gimple_build_assign (vback
, t
);
3988 gsi_insert_before (&gsi
, stmt
, GSI_SAME_STMT
);
3990 t
= build2 (fd
->loop
.cond_code
, boolean_type_node
, vback
, iend
);
3991 stmt
= gimple_build_cond_empty (t
);
3992 gsi_insert_before (&gsi
, stmt
, GSI_SAME_STMT
);
3994 /* Remove GIMPLE_OMP_CONTINUE. */
3995 gsi_remove (&gsi
, true);
3997 if (fd
->collapse
> 1)
3999 basic_block last_bb
, bb
;
4002 for (i
= fd
->collapse
- 1; i
>= 0; i
--)
4004 tree vtype
= TREE_TYPE (fd
->loops
[i
].v
);
4006 bb
= create_empty_bb (last_bb
);
4007 gsi
= gsi_start_bb (bb
);
4009 if (i
< fd
->collapse
- 1)
4011 e
= make_edge (last_bb
, bb
, EDGE_FALSE_VALUE
);
4012 e
->probability
= REG_BR_PROB_BASE
/ 8;
4014 t
= fd
->loops
[i
+ 1].n1
;
4015 t
= force_gimple_operand_gsi (&gsi
, t
, false, NULL_TREE
,
4016 false, GSI_CONTINUE_LINKING
);
4017 stmt
= gimple_build_assign (fd
->loops
[i
+ 1].v
, t
);
4018 gsi_insert_after (&gsi
, stmt
, GSI_CONTINUE_LINKING
);
4023 set_immediate_dominator (CDI_DOMINATORS
, bb
, last_bb
);
4025 if (POINTER_TYPE_P (vtype
))
4026 t
= fold_build_pointer_plus (fd
->loops
[i
].v
, fd
->loops
[i
].step
);
4028 t
= fold_build2 (PLUS_EXPR
, vtype
, fd
->loops
[i
].v
,
4030 t
= force_gimple_operand_gsi (&gsi
, t
, false, NULL_TREE
,
4031 false, GSI_CONTINUE_LINKING
);
4032 stmt
= gimple_build_assign (fd
->loops
[i
].v
, t
);
4033 gsi_insert_after (&gsi
, stmt
, GSI_CONTINUE_LINKING
);
4037 t
= fd
->loops
[i
].n2
;
4038 t
= force_gimple_operand_gsi (&gsi
, t
, true, NULL_TREE
,
4039 false, GSI_CONTINUE_LINKING
);
4040 t
= fold_build2 (fd
->loops
[i
].cond_code
, boolean_type_node
,
4042 stmt
= gimple_build_cond_empty (t
);
4043 gsi_insert_after (&gsi
, stmt
, GSI_CONTINUE_LINKING
);
4044 e
= make_edge (bb
, l1_bb
, EDGE_TRUE_VALUE
);
4045 e
->probability
= REG_BR_PROB_BASE
* 7 / 8;
4048 make_edge (bb
, l1_bb
, EDGE_FALLTHRU
);
4053 /* Emit code to get the next parallel iteration in L2_BB. */
4054 gsi
= gsi_start_bb (l2_bb
);
4056 t
= build_call_expr (builtin_decl_explicit (next_fn
), 2,
4057 build_fold_addr_expr (istart0
),
4058 build_fold_addr_expr (iend0
));
4059 t
= force_gimple_operand_gsi (&gsi
, t
, true, NULL_TREE
,
4060 false, GSI_CONTINUE_LINKING
);
4061 if (TREE_TYPE (t
) != boolean_type_node
)
4062 t
= fold_build2 (NE_EXPR
, boolean_type_node
,
4063 t
, build_int_cst (TREE_TYPE (t
), 0));
4064 stmt
= gimple_build_cond_empty (t
);
4065 gsi_insert_after (&gsi
, stmt
, GSI_CONTINUE_LINKING
);
4068 /* Add the loop cleanup function. */
4069 gsi
= gsi_last_bb (exit_bb
);
4070 if (gimple_omp_return_nowait_p (gsi_stmt (gsi
)))
4071 t
= builtin_decl_explicit (BUILT_IN_GOMP_LOOP_END_NOWAIT
);
4073 t
= builtin_decl_explicit (BUILT_IN_GOMP_LOOP_END
);
4074 stmt
= gimple_build_call (t
, 0);
4075 gsi_insert_after (&gsi
, stmt
, GSI_SAME_STMT
);
4076 gsi_remove (&gsi
, true);
4078 /* Connect the new blocks. */
4079 find_edge (entry_bb
, l0_bb
)->flags
= EDGE_TRUE_VALUE
;
4080 find_edge (entry_bb
, l3_bb
)->flags
= EDGE_FALSE_VALUE
;
4086 e
= find_edge (cont_bb
, l3_bb
);
4087 ne
= make_edge (l2_bb
, l3_bb
, EDGE_FALSE_VALUE
);
4089 phis
= phi_nodes (l3_bb
);
4090 for (gsi
= gsi_start (phis
); !gsi_end_p (gsi
); gsi_next (&gsi
))
4092 gimple phi
= gsi_stmt (gsi
);
4093 SET_USE (PHI_ARG_DEF_PTR_FROM_EDGE (phi
, ne
),
4094 PHI_ARG_DEF_FROM_EDGE (phi
, e
));
4098 make_edge (cont_bb
, l2_bb
, EDGE_FALSE_VALUE
);
4099 if (fd
->collapse
> 1)
4101 e
= find_edge (cont_bb
, l1_bb
);
4103 e
= make_edge (cont_bb
, collapse_bb
, EDGE_TRUE_VALUE
);
4107 e
= find_edge (cont_bb
, l1_bb
);
4108 e
->flags
= EDGE_TRUE_VALUE
;
4110 e
->probability
= REG_BR_PROB_BASE
* 7 / 8;
4111 find_edge (cont_bb
, l2_bb
)->probability
= REG_BR_PROB_BASE
/ 8;
4112 make_edge (l2_bb
, l0_bb
, EDGE_TRUE_VALUE
);
4114 set_immediate_dominator (CDI_DOMINATORS
, l2_bb
,
4115 recompute_dominator (CDI_DOMINATORS
, l2_bb
));
4116 set_immediate_dominator (CDI_DOMINATORS
, l3_bb
,
4117 recompute_dominator (CDI_DOMINATORS
, l3_bb
));
4118 set_immediate_dominator (CDI_DOMINATORS
, l0_bb
,
4119 recompute_dominator (CDI_DOMINATORS
, l0_bb
));
4120 set_immediate_dominator (CDI_DOMINATORS
, l1_bb
,
4121 recompute_dominator (CDI_DOMINATORS
, l1_bb
));
4126 /* A subroutine of expand_omp_for. Generate code for a parallel
4127 loop with static schedule and no specified chunk size. Given
4130 for (V = N1; V cond N2; V += STEP) BODY;
4132 where COND is "<" or ">", we generate pseudocode
4138 if ((__typeof (V)) -1 > 0 && cond is >)
4139 n = -(adj + N2 - N1) / -STEP;
4141 n = (adj + N2 - N1) / STEP;
4144 if (threadid < tt) goto L3; else goto L4;
4149 s0 = q * threadid + tt;
4152 if (s0 >= e0) goto L2; else goto L0;
4158 if (V cond e) goto L1;
4163 expand_omp_for_static_nochunk (struct omp_region
*region
,
4164 struct omp_for_data
*fd
)
4166 tree n
, q
, s0
, e0
, e
, t
, tt
, nthreads
, threadid
;
4167 tree type
, itype
, vmain
, vback
;
4168 basic_block entry_bb
, second_bb
, third_bb
, exit_bb
, seq_start_bb
;
4169 basic_block body_bb
, cont_bb
;
4171 gimple_stmt_iterator gsi
;
4175 itype
= type
= TREE_TYPE (fd
->loop
.v
);
4176 if (POINTER_TYPE_P (type
))
4177 itype
= signed_type_for (type
);
4179 entry_bb
= region
->entry
;
4180 cont_bb
= region
->cont
;
4181 gcc_assert (EDGE_COUNT (entry_bb
->succs
) == 2);
4182 gcc_assert (BRANCH_EDGE (entry_bb
)->dest
== FALLTHRU_EDGE (cont_bb
)->dest
);
4183 seq_start_bb
= split_edge (FALLTHRU_EDGE (entry_bb
));
4184 body_bb
= single_succ (seq_start_bb
);
4185 gcc_assert (BRANCH_EDGE (cont_bb
)->dest
== body_bb
);
4186 gcc_assert (EDGE_COUNT (cont_bb
->succs
) == 2);
4187 fin_bb
= FALLTHRU_EDGE (cont_bb
)->dest
;
4188 exit_bb
= region
->exit
;
4190 /* Iteration space partitioning goes in ENTRY_BB. */
4191 gsi
= gsi_last_bb (entry_bb
);
4192 gcc_assert (gimple_code (gsi_stmt (gsi
)) == GIMPLE_OMP_FOR
);
4194 t
= build_call_expr (builtin_decl_explicit (BUILT_IN_OMP_GET_NUM_THREADS
), 0);
4195 t
= fold_convert (itype
, t
);
4196 nthreads
= force_gimple_operand_gsi (&gsi
, t
, true, NULL_TREE
,
4197 true, GSI_SAME_STMT
);
4199 t
= build_call_expr (builtin_decl_explicit (BUILT_IN_OMP_GET_THREAD_NUM
), 0);
4200 t
= fold_convert (itype
, t
);
4201 threadid
= force_gimple_operand_gsi (&gsi
, t
, true, NULL_TREE
,
4202 true, GSI_SAME_STMT
);
4205 = force_gimple_operand_gsi (&gsi
, fold_convert (type
, fd
->loop
.n1
),
4206 true, NULL_TREE
, true, GSI_SAME_STMT
);
4208 = force_gimple_operand_gsi (&gsi
, fold_convert (itype
, fd
->loop
.n2
),
4209 true, NULL_TREE
, true, GSI_SAME_STMT
);
4211 = force_gimple_operand_gsi (&gsi
, fold_convert (itype
, fd
->loop
.step
),
4212 true, NULL_TREE
, true, GSI_SAME_STMT
);
4214 t
= build_int_cst (itype
, (fd
->loop
.cond_code
== LT_EXPR
? -1 : 1));
4215 t
= fold_build2 (PLUS_EXPR
, itype
, fd
->loop
.step
, t
);
4216 t
= fold_build2 (PLUS_EXPR
, itype
, t
, fd
->loop
.n2
);
4217 t
= fold_build2 (MINUS_EXPR
, itype
, t
, fold_convert (itype
, fd
->loop
.n1
));
4218 if (TYPE_UNSIGNED (itype
) && fd
->loop
.cond_code
== GT_EXPR
)
4219 t
= fold_build2 (TRUNC_DIV_EXPR
, itype
,
4220 fold_build1 (NEGATE_EXPR
, itype
, t
),
4221 fold_build1 (NEGATE_EXPR
, itype
, fd
->loop
.step
));
4223 t
= fold_build2 (TRUNC_DIV_EXPR
, itype
, t
, fd
->loop
.step
);
4224 t
= fold_convert (itype
, t
);
4225 n
= force_gimple_operand_gsi (&gsi
, t
, true, NULL_TREE
, true, GSI_SAME_STMT
);
4227 q
= create_tmp_reg (itype
, "q");
4228 t
= fold_build2 (TRUNC_DIV_EXPR
, itype
, n
, nthreads
);
4229 t
= force_gimple_operand_gsi (&gsi
, t
, false, NULL_TREE
, true, GSI_SAME_STMT
);
4230 gsi_insert_before (&gsi
, gimple_build_assign (q
, t
), GSI_SAME_STMT
);
4232 tt
= create_tmp_reg (itype
, "tt");
4233 t
= fold_build2 (TRUNC_MOD_EXPR
, itype
, n
, nthreads
);
4234 t
= force_gimple_operand_gsi (&gsi
, t
, false, NULL_TREE
, true, GSI_SAME_STMT
);
4235 gsi_insert_before (&gsi
, gimple_build_assign (tt
, t
), GSI_SAME_STMT
);
4237 t
= build2 (LT_EXPR
, boolean_type_node
, threadid
, tt
);
4238 stmt
= gimple_build_cond_empty (t
);
4239 gsi_insert_before (&gsi
, stmt
, GSI_SAME_STMT
);
4241 second_bb
= split_block (entry_bb
, stmt
)->dest
;
4242 gsi
= gsi_last_bb (second_bb
);
4243 gcc_assert (gimple_code (gsi_stmt (gsi
)) == GIMPLE_OMP_FOR
);
4245 gsi_insert_before (&gsi
, gimple_build_assign (tt
, build_int_cst (itype
, 0)),
4247 stmt
= gimple_build_assign_with_ops (PLUS_EXPR
, q
, q
,
4248 build_int_cst (itype
, 1));
4249 gsi_insert_before (&gsi
, stmt
, GSI_SAME_STMT
);
4251 third_bb
= split_block (second_bb
, stmt
)->dest
;
4252 gsi
= gsi_last_bb (third_bb
);
4253 gcc_assert (gimple_code (gsi_stmt (gsi
)) == GIMPLE_OMP_FOR
);
4255 t
= build2 (MULT_EXPR
, itype
, q
, threadid
);
4256 t
= build2 (PLUS_EXPR
, itype
, t
, tt
);
4257 s0
= force_gimple_operand_gsi (&gsi
, t
, true, NULL_TREE
, true, GSI_SAME_STMT
);
4259 t
= fold_build2 (PLUS_EXPR
, itype
, s0
, q
);
4260 e0
= force_gimple_operand_gsi (&gsi
, t
, true, NULL_TREE
, true, GSI_SAME_STMT
);
4262 t
= build2 (GE_EXPR
, boolean_type_node
, s0
, e0
);
4263 gsi_insert_before (&gsi
, gimple_build_cond_empty (t
), GSI_SAME_STMT
);
4265 /* Remove the GIMPLE_OMP_FOR statement. */
4266 gsi_remove (&gsi
, true);
4268 /* Setup code for sequential iteration goes in SEQ_START_BB. */
4269 gsi
= gsi_start_bb (seq_start_bb
);
4271 t
= fold_convert (itype
, s0
);
4272 t
= fold_build2 (MULT_EXPR
, itype
, t
, fd
->loop
.step
);
4273 if (POINTER_TYPE_P (type
))
4274 t
= fold_build_pointer_plus (fd
->loop
.n1
, t
);
4276 t
= fold_build2 (PLUS_EXPR
, type
, t
, fd
->loop
.n1
);
4277 t
= force_gimple_operand_gsi (&gsi
, t
, false, NULL_TREE
,
4278 false, GSI_CONTINUE_LINKING
);
4279 stmt
= gimple_build_assign (fd
->loop
.v
, t
);
4280 gsi_insert_after (&gsi
, stmt
, GSI_CONTINUE_LINKING
);
4282 t
= fold_convert (itype
, e0
);
4283 t
= fold_build2 (MULT_EXPR
, itype
, t
, fd
->loop
.step
);
4284 if (POINTER_TYPE_P (type
))
4285 t
= fold_build_pointer_plus (fd
->loop
.n1
, t
);
4287 t
= fold_build2 (PLUS_EXPR
, type
, t
, fd
->loop
.n1
);
4288 e
= force_gimple_operand_gsi (&gsi
, t
, true, NULL_TREE
,
4289 false, GSI_CONTINUE_LINKING
);
4291 /* The code controlling the sequential loop replaces the
4292 GIMPLE_OMP_CONTINUE. */
4293 gsi
= gsi_last_bb (cont_bb
);
4294 stmt
= gsi_stmt (gsi
);
4295 gcc_assert (gimple_code (stmt
) == GIMPLE_OMP_CONTINUE
);
4296 vmain
= gimple_omp_continue_control_use (stmt
);
4297 vback
= gimple_omp_continue_control_def (stmt
);
4299 if (POINTER_TYPE_P (type
))
4300 t
= fold_build_pointer_plus (vmain
, fd
->loop
.step
);
4302 t
= fold_build2 (PLUS_EXPR
, type
, vmain
, fd
->loop
.step
);
4303 t
= force_gimple_operand_gsi (&gsi
, t
, false, NULL_TREE
,
4304 true, GSI_SAME_STMT
);
4305 stmt
= gimple_build_assign (vback
, t
);
4306 gsi_insert_before (&gsi
, stmt
, GSI_SAME_STMT
);
4308 t
= build2 (fd
->loop
.cond_code
, boolean_type_node
, vback
, e
);
4309 gsi_insert_before (&gsi
, gimple_build_cond_empty (t
), GSI_SAME_STMT
);
4311 /* Remove the GIMPLE_OMP_CONTINUE statement. */
4312 gsi_remove (&gsi
, true);
4314 /* Replace the GIMPLE_OMP_RETURN with a barrier, or nothing. */
4315 gsi
= gsi_last_bb (exit_bb
);
4316 if (!gimple_omp_return_nowait_p (gsi_stmt (gsi
)))
4317 force_gimple_operand_gsi (&gsi
, build_omp_barrier (), false, NULL_TREE
,
4318 false, GSI_SAME_STMT
);
4319 gsi_remove (&gsi
, true);
4321 /* Connect all the blocks. */
4322 ep
= make_edge (entry_bb
, third_bb
, EDGE_FALSE_VALUE
);
4323 ep
->probability
= REG_BR_PROB_BASE
/ 4 * 3;
4324 ep
= find_edge (entry_bb
, second_bb
);
4325 ep
->flags
= EDGE_TRUE_VALUE
;
4326 ep
->probability
= REG_BR_PROB_BASE
/ 4;
4327 find_edge (third_bb
, seq_start_bb
)->flags
= EDGE_FALSE_VALUE
;
4328 find_edge (third_bb
, fin_bb
)->flags
= EDGE_TRUE_VALUE
;
4330 find_edge (cont_bb
, body_bb
)->flags
= EDGE_TRUE_VALUE
;
4331 find_edge (cont_bb
, fin_bb
)->flags
= EDGE_FALSE_VALUE
;
4333 set_immediate_dominator (CDI_DOMINATORS
, second_bb
, entry_bb
);
4334 set_immediate_dominator (CDI_DOMINATORS
, third_bb
, entry_bb
);
4335 set_immediate_dominator (CDI_DOMINATORS
, seq_start_bb
, third_bb
);
4336 set_immediate_dominator (CDI_DOMINATORS
, body_bb
,
4337 recompute_dominator (CDI_DOMINATORS
, body_bb
));
4338 set_immediate_dominator (CDI_DOMINATORS
, fin_bb
,
4339 recompute_dominator (CDI_DOMINATORS
, fin_bb
));
4343 /* A subroutine of expand_omp_for. Generate code for a parallel
4344 loop with static schedule and a specified chunk size. Given
4347 for (V = N1; V cond N2; V += STEP) BODY;
4349 where COND is "<" or ">", we generate pseudocode
4355 if ((__typeof (V)) -1 > 0 && cond is >)
4356 n = -(adj + N2 - N1) / -STEP;
4358 n = (adj + N2 - N1) / STEP;
4360 V = threadid * CHUNK * STEP + N1; -- this extra definition of V is
4361 here so that V is defined
4362 if the loop is not entered
4364 s0 = (trip * nthreads + threadid) * CHUNK;
4365 e0 = min(s0 + CHUNK, n);
4366 if (s0 < n) goto L1; else goto L4;
4373 if (V cond e) goto L2; else goto L3;
4381 expand_omp_for_static_chunk (struct omp_region
*region
, struct omp_for_data
*fd
)
4383 tree n
, s0
, e0
, e
, t
;
4384 tree trip_var
, trip_init
, trip_main
, trip_back
, nthreads
, threadid
;
4385 tree type
, itype
, v_main
, v_back
, v_extra
;
4386 basic_block entry_bb
, exit_bb
, body_bb
, seq_start_bb
, iter_part_bb
;
4387 basic_block trip_update_bb
, cont_bb
, fin_bb
;
4388 gimple_stmt_iterator si
;
4392 itype
= type
= TREE_TYPE (fd
->loop
.v
);
4393 if (POINTER_TYPE_P (type
))
4394 itype
= signed_type_for (type
);
4396 entry_bb
= region
->entry
;
4397 se
= split_block (entry_bb
, last_stmt (entry_bb
));
4399 iter_part_bb
= se
->dest
;
4400 cont_bb
= region
->cont
;
4401 gcc_assert (EDGE_COUNT (iter_part_bb
->succs
) == 2);
4402 gcc_assert (BRANCH_EDGE (iter_part_bb
)->dest
4403 == FALLTHRU_EDGE (cont_bb
)->dest
);
4404 seq_start_bb
= split_edge (FALLTHRU_EDGE (iter_part_bb
));
4405 body_bb
= single_succ (seq_start_bb
);
4406 gcc_assert (BRANCH_EDGE (cont_bb
)->dest
== body_bb
);
4407 gcc_assert (EDGE_COUNT (cont_bb
->succs
) == 2);
4408 fin_bb
= FALLTHRU_EDGE (cont_bb
)->dest
;
4409 trip_update_bb
= split_edge (FALLTHRU_EDGE (cont_bb
));
4410 exit_bb
= region
->exit
;
4412 /* Trip and adjustment setup goes in ENTRY_BB. */
4413 si
= gsi_last_bb (entry_bb
);
4414 gcc_assert (gimple_code (gsi_stmt (si
)) == GIMPLE_OMP_FOR
);
4416 t
= build_call_expr (builtin_decl_explicit (BUILT_IN_OMP_GET_NUM_THREADS
), 0);
4417 t
= fold_convert (itype
, t
);
4418 nthreads
= force_gimple_operand_gsi (&si
, t
, true, NULL_TREE
,
4419 true, GSI_SAME_STMT
);
4421 t
= build_call_expr (builtin_decl_explicit (BUILT_IN_OMP_GET_THREAD_NUM
), 0);
4422 t
= fold_convert (itype
, t
);
4423 threadid
= force_gimple_operand_gsi (&si
, t
, true, NULL_TREE
,
4424 true, GSI_SAME_STMT
);
4427 = force_gimple_operand_gsi (&si
, fold_convert (type
, fd
->loop
.n1
),
4428 true, NULL_TREE
, true, GSI_SAME_STMT
);
4430 = force_gimple_operand_gsi (&si
, fold_convert (itype
, fd
->loop
.n2
),
4431 true, NULL_TREE
, true, GSI_SAME_STMT
);
4433 = force_gimple_operand_gsi (&si
, fold_convert (itype
, fd
->loop
.step
),
4434 true, NULL_TREE
, true, GSI_SAME_STMT
);
4436 = force_gimple_operand_gsi (&si
, fold_convert (itype
, fd
->chunk_size
),
4437 true, NULL_TREE
, true, GSI_SAME_STMT
);
4439 t
= build_int_cst (itype
, (fd
->loop
.cond_code
== LT_EXPR
? -1 : 1));
4440 t
= fold_build2 (PLUS_EXPR
, itype
, fd
->loop
.step
, t
);
4441 t
= fold_build2 (PLUS_EXPR
, itype
, t
, fd
->loop
.n2
);
4442 t
= fold_build2 (MINUS_EXPR
, itype
, t
, fold_convert (itype
, fd
->loop
.n1
));
4443 if (TYPE_UNSIGNED (itype
) && fd
->loop
.cond_code
== GT_EXPR
)
4444 t
= fold_build2 (TRUNC_DIV_EXPR
, itype
,
4445 fold_build1 (NEGATE_EXPR
, itype
, t
),
4446 fold_build1 (NEGATE_EXPR
, itype
, fd
->loop
.step
));
4448 t
= fold_build2 (TRUNC_DIV_EXPR
, itype
, t
, fd
->loop
.step
);
4449 t
= fold_convert (itype
, t
);
4450 n
= force_gimple_operand_gsi (&si
, t
, true, NULL_TREE
,
4451 true, GSI_SAME_STMT
);
4453 trip_var
= create_tmp_reg (itype
, ".trip");
4454 if (gimple_in_ssa_p (cfun
))
4456 trip_init
= make_ssa_name (trip_var
, NULL
);
4457 trip_main
= make_ssa_name (trip_var
, NULL
);
4458 trip_back
= make_ssa_name (trip_var
, NULL
);
4462 trip_init
= trip_var
;
4463 trip_main
= trip_var
;
4464 trip_back
= trip_var
;
4467 stmt
= gimple_build_assign (trip_init
, build_int_cst (itype
, 0));
4468 gsi_insert_before (&si
, stmt
, GSI_SAME_STMT
);
4470 t
= fold_build2 (MULT_EXPR
, itype
, threadid
, fd
->chunk_size
);
4471 t
= fold_build2 (MULT_EXPR
, itype
, t
, fd
->loop
.step
);
4472 if (POINTER_TYPE_P (type
))
4473 t
= fold_build_pointer_plus (fd
->loop
.n1
, t
);
4475 t
= fold_build2 (PLUS_EXPR
, type
, t
, fd
->loop
.n1
);
4476 v_extra
= force_gimple_operand_gsi (&si
, t
, true, NULL_TREE
,
4477 true, GSI_SAME_STMT
);
4479 /* Remove the GIMPLE_OMP_FOR. */
4480 gsi_remove (&si
, true);
4482 /* Iteration space partitioning goes in ITER_PART_BB. */
4483 si
= gsi_last_bb (iter_part_bb
);
4485 t
= fold_build2 (MULT_EXPR
, itype
, trip_main
, nthreads
);
4486 t
= fold_build2 (PLUS_EXPR
, itype
, t
, threadid
);
4487 t
= fold_build2 (MULT_EXPR
, itype
, t
, fd
->chunk_size
);
4488 s0
= force_gimple_operand_gsi (&si
, t
, true, NULL_TREE
,
4489 false, GSI_CONTINUE_LINKING
);
4491 t
= fold_build2 (PLUS_EXPR
, itype
, s0
, fd
->chunk_size
);
4492 t
= fold_build2 (MIN_EXPR
, itype
, t
, n
);
4493 e0
= force_gimple_operand_gsi (&si
, t
, true, NULL_TREE
,
4494 false, GSI_CONTINUE_LINKING
);
4496 t
= build2 (LT_EXPR
, boolean_type_node
, s0
, n
);
4497 gsi_insert_after (&si
, gimple_build_cond_empty (t
), GSI_CONTINUE_LINKING
);
4499 /* Setup code for sequential iteration goes in SEQ_START_BB. */
4500 si
= gsi_start_bb (seq_start_bb
);
4502 t
= fold_convert (itype
, s0
);
4503 t
= fold_build2 (MULT_EXPR
, itype
, t
, fd
->loop
.step
);
4504 if (POINTER_TYPE_P (type
))
4505 t
= fold_build_pointer_plus (fd
->loop
.n1
, t
);
4507 t
= fold_build2 (PLUS_EXPR
, type
, t
, fd
->loop
.n1
);
4508 t
= force_gimple_operand_gsi (&si
, t
, false, NULL_TREE
,
4509 false, GSI_CONTINUE_LINKING
);
4510 stmt
= gimple_build_assign (fd
->loop
.v
, t
);
4511 gsi_insert_after (&si
, stmt
, GSI_CONTINUE_LINKING
);
4513 t
= fold_convert (itype
, e0
);
4514 t
= fold_build2 (MULT_EXPR
, itype
, t
, fd
->loop
.step
);
4515 if (POINTER_TYPE_P (type
))
4516 t
= fold_build_pointer_plus (fd
->loop
.n1
, t
);
4518 t
= fold_build2 (PLUS_EXPR
, type
, t
, fd
->loop
.n1
);
4519 e
= force_gimple_operand_gsi (&si
, t
, true, NULL_TREE
,
4520 false, GSI_CONTINUE_LINKING
);
4522 /* The code controlling the sequential loop goes in CONT_BB,
4523 replacing the GIMPLE_OMP_CONTINUE. */
4524 si
= gsi_last_bb (cont_bb
);
4525 stmt
= gsi_stmt (si
);
4526 gcc_assert (gimple_code (stmt
) == GIMPLE_OMP_CONTINUE
);
4527 v_main
= gimple_omp_continue_control_use (stmt
);
4528 v_back
= gimple_omp_continue_control_def (stmt
);
4530 if (POINTER_TYPE_P (type
))
4531 t
= fold_build_pointer_plus (v_main
, fd
->loop
.step
);
4533 t
= fold_build2 (PLUS_EXPR
, type
, v_main
, fd
->loop
.step
);
4534 stmt
= gimple_build_assign (v_back
, t
);
4535 gsi_insert_before (&si
, stmt
, GSI_SAME_STMT
);
4537 t
= build2 (fd
->loop
.cond_code
, boolean_type_node
, v_back
, e
);
4538 gsi_insert_before (&si
, gimple_build_cond_empty (t
), GSI_SAME_STMT
);
4540 /* Remove GIMPLE_OMP_CONTINUE. */
4541 gsi_remove (&si
, true);
4543 /* Trip update code goes into TRIP_UPDATE_BB. */
4544 si
= gsi_start_bb (trip_update_bb
);
4546 t
= build_int_cst (itype
, 1);
4547 t
= build2 (PLUS_EXPR
, itype
, trip_main
, t
);
4548 stmt
= gimple_build_assign (trip_back
, t
);
4549 gsi_insert_after (&si
, stmt
, GSI_CONTINUE_LINKING
);
4551 /* Replace the GIMPLE_OMP_RETURN with a barrier, or nothing. */
4552 si
= gsi_last_bb (exit_bb
);
4553 if (!gimple_omp_return_nowait_p (gsi_stmt (si
)))
4554 force_gimple_operand_gsi (&si
, build_omp_barrier (), false, NULL_TREE
,
4555 false, GSI_SAME_STMT
);
4556 gsi_remove (&si
, true);
4558 /* Connect the new blocks. */
4559 find_edge (iter_part_bb
, seq_start_bb
)->flags
= EDGE_TRUE_VALUE
;
4560 find_edge (iter_part_bb
, fin_bb
)->flags
= EDGE_FALSE_VALUE
;
4562 find_edge (cont_bb
, body_bb
)->flags
= EDGE_TRUE_VALUE
;
4563 find_edge (cont_bb
, trip_update_bb
)->flags
= EDGE_FALSE_VALUE
;
4565 redirect_edge_and_branch (single_succ_edge (trip_update_bb
), iter_part_bb
);
4567 if (gimple_in_ssa_p (cfun
))
4569 gimple_stmt_iterator psi
;
4572 edge_var_map_vector head
;
4576 /* When we redirect the edge from trip_update_bb to iter_part_bb, we
4577 remove arguments of the phi nodes in fin_bb. We need to create
4578 appropriate phi nodes in iter_part_bb instead. */
4579 se
= single_pred_edge (fin_bb
);
4580 re
= single_succ_edge (trip_update_bb
);
4581 head
= redirect_edge_var_map_vector (re
);
4582 ene
= single_succ_edge (entry_bb
);
4584 psi
= gsi_start_phis (fin_bb
);
4585 for (i
= 0; !gsi_end_p (psi
) && VEC_iterate (edge_var_map
, head
, i
, vm
);
4586 gsi_next (&psi
), ++i
)
4589 source_location locus
;
4591 phi
= gsi_stmt (psi
);
4592 t
= gimple_phi_result (phi
);
4593 gcc_assert (t
== redirect_edge_var_map_result (vm
));
4594 nphi
= create_phi_node (t
, iter_part_bb
);
4595 SSA_NAME_DEF_STMT (t
) = nphi
;
4597 t
= PHI_ARG_DEF_FROM_EDGE (phi
, se
);
4598 locus
= gimple_phi_arg_location_from_edge (phi
, se
);
4600 /* A special case -- fd->loop.v is not yet computed in
4601 iter_part_bb, we need to use v_extra instead. */
4602 if (t
== fd
->loop
.v
)
4604 add_phi_arg (nphi
, t
, ene
, locus
);
4605 locus
= redirect_edge_var_map_location (vm
);
4606 add_phi_arg (nphi
, redirect_edge_var_map_def (vm
), re
, locus
);
4608 gcc_assert (!gsi_end_p (psi
) && i
== VEC_length (edge_var_map
, head
));
4609 redirect_edge_var_map_clear (re
);
4612 psi
= gsi_start_phis (fin_bb
);
4613 if (gsi_end_p (psi
))
4615 remove_phi_node (&psi
, false);
4618 /* Make phi node for trip. */
4619 phi
= create_phi_node (trip_main
, iter_part_bb
);
4620 SSA_NAME_DEF_STMT (trip_main
) = phi
;
4621 add_phi_arg (phi
, trip_back
, single_succ_edge (trip_update_bb
),
4623 add_phi_arg (phi
, trip_init
, single_succ_edge (entry_bb
),
4627 set_immediate_dominator (CDI_DOMINATORS
, trip_update_bb
, cont_bb
);
4628 set_immediate_dominator (CDI_DOMINATORS
, iter_part_bb
,
4629 recompute_dominator (CDI_DOMINATORS
, iter_part_bb
));
4630 set_immediate_dominator (CDI_DOMINATORS
, fin_bb
,
4631 recompute_dominator (CDI_DOMINATORS
, fin_bb
));
4632 set_immediate_dominator (CDI_DOMINATORS
, seq_start_bb
,
4633 recompute_dominator (CDI_DOMINATORS
, seq_start_bb
));
4634 set_immediate_dominator (CDI_DOMINATORS
, body_bb
,
4635 recompute_dominator (CDI_DOMINATORS
, body_bb
));
4639 /* Expand the OpenMP loop defined by REGION. */
4642 expand_omp_for (struct omp_region
*region
)
4644 struct omp_for_data fd
;
4645 struct omp_for_data_loop
*loops
;
4648 = (struct omp_for_data_loop
*)
4649 alloca (gimple_omp_for_collapse (last_stmt (region
->entry
))
4650 * sizeof (struct omp_for_data_loop
));
4651 extract_omp_for_data (last_stmt (region
->entry
), &fd
, loops
);
4652 region
->sched_kind
= fd
.sched_kind
;
4654 gcc_assert (EDGE_COUNT (region
->entry
->succs
) == 2);
4655 BRANCH_EDGE (region
->entry
)->flags
&= ~EDGE_ABNORMAL
;
4656 FALLTHRU_EDGE (region
->entry
)->flags
&= ~EDGE_ABNORMAL
;
4659 gcc_assert (EDGE_COUNT (region
->cont
->succs
) == 2);
4660 BRANCH_EDGE (region
->cont
)->flags
&= ~EDGE_ABNORMAL
;
4661 FALLTHRU_EDGE (region
->cont
)->flags
&= ~EDGE_ABNORMAL
;
4664 if (fd
.sched_kind
== OMP_CLAUSE_SCHEDULE_STATIC
4667 && region
->cont
!= NULL
)
4669 if (fd
.chunk_size
== NULL
)
4670 expand_omp_for_static_nochunk (region
, &fd
);
4672 expand_omp_for_static_chunk (region
, &fd
);
4676 int fn_index
, start_ix
, next_ix
;
4678 if (fd
.chunk_size
== NULL
4679 && fd
.sched_kind
== OMP_CLAUSE_SCHEDULE_STATIC
)
4680 fd
.chunk_size
= integer_zero_node
;
4681 gcc_assert (fd
.sched_kind
!= OMP_CLAUSE_SCHEDULE_AUTO
);
4682 fn_index
= (fd
.sched_kind
== OMP_CLAUSE_SCHEDULE_RUNTIME
)
4683 ? 3 : fd
.sched_kind
;
4684 fn_index
+= fd
.have_ordered
* 4;
4685 start_ix
= ((int)BUILT_IN_GOMP_LOOP_STATIC_START
) + fn_index
;
4686 next_ix
= ((int)BUILT_IN_GOMP_LOOP_STATIC_NEXT
) + fn_index
;
4687 if (fd
.iter_type
== long_long_unsigned_type_node
)
4689 start_ix
+= ((int)BUILT_IN_GOMP_LOOP_ULL_STATIC_START
4690 - (int)BUILT_IN_GOMP_LOOP_STATIC_START
);
4691 next_ix
+= ((int)BUILT_IN_GOMP_LOOP_ULL_STATIC_NEXT
4692 - (int)BUILT_IN_GOMP_LOOP_STATIC_NEXT
);
4694 expand_omp_for_generic (region
, &fd
, (enum built_in_function
) start_ix
,
4695 (enum built_in_function
) next_ix
);
4698 if (gimple_in_ssa_p (cfun
))
4699 update_ssa (TODO_update_ssa_only_virtuals
);
4703 /* Expand code for an OpenMP sections directive. In pseudo code, we generate
4705 v = GOMP_sections_start (n);
4722 v = GOMP_sections_next ();
4727 If this is a combined parallel sections, replace the call to
4728 GOMP_sections_start with call to GOMP_sections_next. */
4731 expand_omp_sections (struct omp_region
*region
)
4733 tree t
, u
, vin
= NULL
, vmain
, vnext
, l2
;
4734 VEC (tree
,heap
) *label_vec
;
4736 basic_block entry_bb
, l0_bb
, l1_bb
, l2_bb
, default_bb
;
4737 gimple_stmt_iterator si
, switch_si
;
4738 gimple sections_stmt
, stmt
, cont
;
4741 struct omp_region
*inner
;
4743 bool exit_reachable
= region
->cont
!= NULL
;
4745 gcc_assert (region
->exit
!= NULL
);
4746 entry_bb
= region
->entry
;
4747 l0_bb
= single_succ (entry_bb
);
4748 l1_bb
= region
->cont
;
4749 l2_bb
= region
->exit
;
4750 if (single_pred_p (l2_bb
) && single_pred (l2_bb
) == l0_bb
)
4751 l2
= gimple_block_label (l2_bb
);
4754 /* This can happen if there are reductions. */
4755 len
= EDGE_COUNT (l0_bb
->succs
);
4756 gcc_assert (len
> 0);
4757 e
= EDGE_SUCC (l0_bb
, len
- 1);
4758 si
= gsi_last_bb (e
->dest
);
4761 || gimple_code (gsi_stmt (si
)) != GIMPLE_OMP_SECTION
)
4762 l2
= gimple_block_label (e
->dest
);
4764 FOR_EACH_EDGE (e
, ei
, l0_bb
->succs
)
4766 si
= gsi_last_bb (e
->dest
);
4768 || gimple_code (gsi_stmt (si
)) != GIMPLE_OMP_SECTION
)
4770 l2
= gimple_block_label (e
->dest
);
4776 default_bb
= create_empty_bb (l1_bb
->prev_bb
);
4778 default_bb
= create_empty_bb (l0_bb
);
4780 /* We will build a switch() with enough cases for all the
4781 GIMPLE_OMP_SECTION regions, a '0' case to handle the end of more work
4782 and a default case to abort if something goes wrong. */
4783 len
= EDGE_COUNT (l0_bb
->succs
);
4785 /* Use VEC_quick_push on label_vec throughout, since we know the size
4787 label_vec
= VEC_alloc (tree
, heap
, len
);
4789 /* The call to GOMP_sections_start goes in ENTRY_BB, replacing the
4790 GIMPLE_OMP_SECTIONS statement. */
4791 si
= gsi_last_bb (entry_bb
);
4792 sections_stmt
= gsi_stmt (si
);
4793 gcc_assert (gimple_code (sections_stmt
) == GIMPLE_OMP_SECTIONS
);
4794 vin
= gimple_omp_sections_control (sections_stmt
);
4795 if (!is_combined_parallel (region
))
4797 /* If we are not inside a combined parallel+sections region,
4798 call GOMP_sections_start. */
4799 t
= build_int_cst (unsigned_type_node
,
4800 exit_reachable
? len
- 1 : len
);
4801 u
= builtin_decl_explicit (BUILT_IN_GOMP_SECTIONS_START
);
4802 stmt
= gimple_build_call (u
, 1, t
);
4806 /* Otherwise, call GOMP_sections_next. */
4807 u
= builtin_decl_explicit (BUILT_IN_GOMP_SECTIONS_NEXT
);
4808 stmt
= gimple_build_call (u
, 0);
4810 gimple_call_set_lhs (stmt
, vin
);
4811 gsi_insert_after (&si
, stmt
, GSI_SAME_STMT
);
4812 gsi_remove (&si
, true);
4814 /* The switch() statement replacing GIMPLE_OMP_SECTIONS_SWITCH goes in
4816 switch_si
= gsi_last_bb (l0_bb
);
4817 gcc_assert (gimple_code (gsi_stmt (switch_si
)) == GIMPLE_OMP_SECTIONS_SWITCH
);
4820 cont
= last_stmt (l1_bb
);
4821 gcc_assert (gimple_code (cont
) == GIMPLE_OMP_CONTINUE
);
4822 vmain
= gimple_omp_continue_control_use (cont
);
4823 vnext
= gimple_omp_continue_control_def (cont
);
4831 t
= build_case_label (build_int_cst (unsigned_type_node
, 0), NULL
, l2
);
4832 VEC_quick_push (tree
, label_vec
, t
);
4835 /* Convert each GIMPLE_OMP_SECTION into a CASE_LABEL_EXPR. */
4836 for (inner
= region
->inner
, casei
= 1;
4838 inner
= inner
->next
, i
++, casei
++)
4840 basic_block s_entry_bb
, s_exit_bb
;
4842 /* Skip optional reduction region. */
4843 if (inner
->type
== GIMPLE_OMP_ATOMIC_LOAD
)
4850 s_entry_bb
= inner
->entry
;
4851 s_exit_bb
= inner
->exit
;
4853 t
= gimple_block_label (s_entry_bb
);
4854 u
= build_int_cst (unsigned_type_node
, casei
);
4855 u
= build_case_label (u
, NULL
, t
);
4856 VEC_quick_push (tree
, label_vec
, u
);
4858 si
= gsi_last_bb (s_entry_bb
);
4859 gcc_assert (gimple_code (gsi_stmt (si
)) == GIMPLE_OMP_SECTION
);
4860 gcc_assert (i
< len
|| gimple_omp_section_last_p (gsi_stmt (si
)));
4861 gsi_remove (&si
, true);
4862 single_succ_edge (s_entry_bb
)->flags
= EDGE_FALLTHRU
;
4864 if (s_exit_bb
== NULL
)
4867 si
= gsi_last_bb (s_exit_bb
);
4868 gcc_assert (gimple_code (gsi_stmt (si
)) == GIMPLE_OMP_RETURN
);
4869 gsi_remove (&si
, true);
4871 single_succ_edge (s_exit_bb
)->flags
= EDGE_FALLTHRU
;
4874 /* Error handling code goes in DEFAULT_BB. */
4875 t
= gimple_block_label (default_bb
);
4876 u
= build_case_label (NULL
, NULL
, t
);
4877 make_edge (l0_bb
, default_bb
, 0);
4879 stmt
= gimple_build_switch_vec (vmain
, u
, label_vec
);
4880 gsi_insert_after (&switch_si
, stmt
, GSI_SAME_STMT
);
4881 gsi_remove (&switch_si
, true);
4882 VEC_free (tree
, heap
, label_vec
);
4884 si
= gsi_start_bb (default_bb
);
4885 stmt
= gimple_build_call (builtin_decl_explicit (BUILT_IN_TRAP
), 0);
4886 gsi_insert_after (&si
, stmt
, GSI_CONTINUE_LINKING
);
4892 /* Code to get the next section goes in L1_BB. */
4893 si
= gsi_last_bb (l1_bb
);
4894 gcc_assert (gimple_code (gsi_stmt (si
)) == GIMPLE_OMP_CONTINUE
);
4896 bfn_decl
= builtin_decl_explicit (BUILT_IN_GOMP_SECTIONS_NEXT
);
4897 stmt
= gimple_build_call (bfn_decl
, 0);
4898 gimple_call_set_lhs (stmt
, vnext
);
4899 gsi_insert_after (&si
, stmt
, GSI_SAME_STMT
);
4900 gsi_remove (&si
, true);
4902 single_succ_edge (l1_bb
)->flags
= EDGE_FALLTHRU
;
4905 /* Cleanup function replaces GIMPLE_OMP_RETURN in EXIT_BB. */
4906 si
= gsi_last_bb (l2_bb
);
4907 if (gimple_omp_return_nowait_p (gsi_stmt (si
)))
4908 t
= builtin_decl_explicit (BUILT_IN_GOMP_SECTIONS_END_NOWAIT
);
4910 t
= builtin_decl_explicit (BUILT_IN_GOMP_SECTIONS_END
);
4911 stmt
= gimple_build_call (t
, 0);
4912 gsi_insert_after (&si
, stmt
, GSI_SAME_STMT
);
4913 gsi_remove (&si
, true);
4915 set_immediate_dominator (CDI_DOMINATORS
, default_bb
, l0_bb
);
4919 /* Expand code for an OpenMP single directive. We've already expanded
4920 much of the code, here we simply place the GOMP_barrier call. */
4923 expand_omp_single (struct omp_region
*region
)
4925 basic_block entry_bb
, exit_bb
;
4926 gimple_stmt_iterator si
;
4927 bool need_barrier
= false;
4929 entry_bb
= region
->entry
;
4930 exit_bb
= region
->exit
;
4932 si
= gsi_last_bb (entry_bb
);
4933 /* The terminal barrier at the end of a GOMP_single_copy sequence cannot
4934 be removed. We need to ensure that the thread that entered the single
4935 does not exit before the data is copied out by the other threads. */
4936 if (find_omp_clause (gimple_omp_single_clauses (gsi_stmt (si
)),
4937 OMP_CLAUSE_COPYPRIVATE
))
4938 need_barrier
= true;
4939 gcc_assert (gimple_code (gsi_stmt (si
)) == GIMPLE_OMP_SINGLE
);
4940 gsi_remove (&si
, true);
4941 single_succ_edge (entry_bb
)->flags
= EDGE_FALLTHRU
;
4943 si
= gsi_last_bb (exit_bb
);
4944 if (!gimple_omp_return_nowait_p (gsi_stmt (si
)) || need_barrier
)
4945 force_gimple_operand_gsi (&si
, build_omp_barrier (), false, NULL_TREE
,
4946 false, GSI_SAME_STMT
);
4947 gsi_remove (&si
, true);
4948 single_succ_edge (exit_bb
)->flags
= EDGE_FALLTHRU
;
4952 /* Generic expansion for OpenMP synchronization directives: master,
4953 ordered and critical. All we need to do here is remove the entry
4954 and exit markers for REGION. */
4957 expand_omp_synch (struct omp_region
*region
)
4959 basic_block entry_bb
, exit_bb
;
4960 gimple_stmt_iterator si
;
4962 entry_bb
= region
->entry
;
4963 exit_bb
= region
->exit
;
4965 si
= gsi_last_bb (entry_bb
);
4966 gcc_assert (gimple_code (gsi_stmt (si
)) == GIMPLE_OMP_SINGLE
4967 || gimple_code (gsi_stmt (si
)) == GIMPLE_OMP_MASTER
4968 || gimple_code (gsi_stmt (si
)) == GIMPLE_OMP_ORDERED
4969 || gimple_code (gsi_stmt (si
)) == GIMPLE_OMP_CRITICAL
);
4970 gsi_remove (&si
, true);
4971 single_succ_edge (entry_bb
)->flags
= EDGE_FALLTHRU
;
4975 si
= gsi_last_bb (exit_bb
);
4976 gcc_assert (gimple_code (gsi_stmt (si
)) == GIMPLE_OMP_RETURN
);
4977 gsi_remove (&si
, true);
4978 single_succ_edge (exit_bb
)->flags
= EDGE_FALLTHRU
;
4982 /* A subroutine of expand_omp_atomic. Attempt to implement the atomic
4983 operation as a normal volatile load. */
4986 expand_omp_atomic_load (basic_block load_bb
, tree addr
,
4987 tree loaded_val
, int index
)
4989 enum built_in_function tmpbase
;
4990 gimple_stmt_iterator gsi
;
4991 basic_block store_bb
;
4994 tree decl
, call
, type
, itype
;
4996 gsi
= gsi_last_bb (load_bb
);
4997 stmt
= gsi_stmt (gsi
);
4998 gcc_assert (gimple_code (stmt
) == GIMPLE_OMP_ATOMIC_LOAD
);
4999 loc
= gimple_location (stmt
);
5001 /* ??? If the target does not implement atomic_load_optab[mode], and mode
5002 is smaller than word size, then expand_atomic_load assumes that the load
5003 is atomic. We could avoid the builtin entirely in this case. */
5005 tmpbase
= (enum built_in_function
) (BUILT_IN_ATOMIC_LOAD_N
+ index
+ 1);
5006 decl
= builtin_decl_explicit (tmpbase
);
5007 if (decl
== NULL_TREE
)
5010 type
= TREE_TYPE (loaded_val
);
5011 itype
= TREE_TYPE (TREE_TYPE (decl
));
5013 call
= build_call_expr_loc (loc
, decl
, 2, addr
,
5014 build_int_cst (NULL
, MEMMODEL_RELAXED
));
5015 if (!useless_type_conversion_p (type
, itype
))
5016 call
= fold_build1_loc (loc
, VIEW_CONVERT_EXPR
, type
, call
);
5017 call
= build2_loc (loc
, MODIFY_EXPR
, void_type_node
, loaded_val
, call
);
5019 force_gimple_operand_gsi (&gsi
, call
, true, NULL_TREE
, true, GSI_SAME_STMT
);
5020 gsi_remove (&gsi
, true);
5022 store_bb
= single_succ (load_bb
);
5023 gsi
= gsi_last_bb (store_bb
);
5024 gcc_assert (gimple_code (gsi_stmt (gsi
)) == GIMPLE_OMP_ATOMIC_STORE
);
5025 gsi_remove (&gsi
, true);
5027 if (gimple_in_ssa_p (cfun
))
5028 update_ssa (TODO_update_ssa_no_phi
);
5033 /* A subroutine of expand_omp_atomic. Attempt to implement the atomic
5034 operation as a normal volatile store. */
5037 expand_omp_atomic_store (basic_block load_bb
, tree addr
,
5038 tree loaded_val
, tree stored_val
, int index
)
5040 enum built_in_function tmpbase
;
5041 gimple_stmt_iterator gsi
;
5042 basic_block store_bb
= single_succ (load_bb
);
5045 tree decl
, call
, type
, itype
;
5046 enum machine_mode imode
;
5049 gsi
= gsi_last_bb (load_bb
);
5050 stmt
= gsi_stmt (gsi
);
5051 gcc_assert (gimple_code (stmt
) == GIMPLE_OMP_ATOMIC_LOAD
);
5053 /* If the load value is needed, then this isn't a store but an exchange. */
5054 exchange
= gimple_omp_atomic_need_value_p (stmt
);
5056 gsi
= gsi_last_bb (store_bb
);
5057 stmt
= gsi_stmt (gsi
);
5058 gcc_assert (gimple_code (stmt
) == GIMPLE_OMP_ATOMIC_STORE
);
5059 loc
= gimple_location (stmt
);
5061 /* ??? If the target does not implement atomic_store_optab[mode], and mode
5062 is smaller than word size, then expand_atomic_store assumes that the store
5063 is atomic. We could avoid the builtin entirely in this case. */
5065 tmpbase
= (exchange
? BUILT_IN_ATOMIC_EXCHANGE_N
: BUILT_IN_ATOMIC_STORE_N
);
5066 tmpbase
= (enum built_in_function
) ((int) tmpbase
+ index
+ 1);
5067 decl
= builtin_decl_explicit (tmpbase
);
5068 if (decl
== NULL_TREE
)
5071 type
= TREE_TYPE (stored_val
);
5073 /* Dig out the type of the function's second argument. */
5074 itype
= TREE_TYPE (decl
);
5075 itype
= TYPE_ARG_TYPES (itype
);
5076 itype
= TREE_CHAIN (itype
);
5077 itype
= TREE_VALUE (itype
);
5078 imode
= TYPE_MODE (itype
);
5080 if (exchange
&& !can_atomic_exchange_p (imode
, true))
5083 if (!useless_type_conversion_p (itype
, type
))
5084 stored_val
= fold_build1_loc (loc
, VIEW_CONVERT_EXPR
, itype
, stored_val
);
5085 call
= build_call_expr_loc (loc
, decl
, 3, addr
, stored_val
,
5086 build_int_cst (NULL
, MEMMODEL_RELAXED
));
5089 if (!useless_type_conversion_p (type
, itype
))
5090 call
= build1_loc (loc
, VIEW_CONVERT_EXPR
, type
, call
);
5091 call
= build2_loc (loc
, MODIFY_EXPR
, void_type_node
, loaded_val
, call
);
5094 force_gimple_operand_gsi (&gsi
, call
, true, NULL_TREE
, true, GSI_SAME_STMT
);
5095 gsi_remove (&gsi
, true);
5097 /* Remove the GIMPLE_OMP_ATOMIC_LOAD that we verified above. */
5098 gsi
= gsi_last_bb (load_bb
);
5099 gsi_remove (&gsi
, true);
5101 if (gimple_in_ssa_p (cfun
))
5102 update_ssa (TODO_update_ssa_no_phi
);
5107 /* A subroutine of expand_omp_atomic. Attempt to implement the atomic
5108 operation as a __atomic_fetch_op builtin. INDEX is log2 of the
5109 size of the data type, and thus usable to find the index of the builtin
5110 decl. Returns false if the expression is not of the proper form. */
5113 expand_omp_atomic_fetch_op (basic_block load_bb
,
5114 tree addr
, tree loaded_val
,
5115 tree stored_val
, int index
)
5117 enum built_in_function oldbase
, newbase
, tmpbase
;
5118 tree decl
, itype
, call
;
5120 basic_block store_bb
= single_succ (load_bb
);
5121 gimple_stmt_iterator gsi
;
5124 enum tree_code code
;
5125 bool need_old
, need_new
;
5126 enum machine_mode imode
;
5128 /* We expect to find the following sequences:
5131 GIMPLE_OMP_ATOMIC_LOAD (tmp, mem)
5134 val = tmp OP something; (or: something OP tmp)
5135 GIMPLE_OMP_STORE (val)
5137 ???FIXME: Allow a more flexible sequence.
5138 Perhaps use data flow to pick the statements.
5142 gsi
= gsi_after_labels (store_bb
);
5143 stmt
= gsi_stmt (gsi
);
5144 loc
= gimple_location (stmt
);
5145 if (!is_gimple_assign (stmt
))
5148 if (gimple_code (gsi_stmt (gsi
)) != GIMPLE_OMP_ATOMIC_STORE
)
5150 need_new
= gimple_omp_atomic_need_value_p (gsi_stmt (gsi
));
5151 need_old
= gimple_omp_atomic_need_value_p (last_stmt (load_bb
));
5152 gcc_checking_assert (!need_old
|| !need_new
);
5154 if (!operand_equal_p (gimple_assign_lhs (stmt
), stored_val
, 0))
5157 /* Check for one of the supported fetch-op operations. */
5158 code
= gimple_assign_rhs_code (stmt
);
5162 case POINTER_PLUS_EXPR
:
5163 oldbase
= BUILT_IN_ATOMIC_FETCH_ADD_N
;
5164 newbase
= BUILT_IN_ATOMIC_ADD_FETCH_N
;
5167 oldbase
= BUILT_IN_ATOMIC_FETCH_SUB_N
;
5168 newbase
= BUILT_IN_ATOMIC_SUB_FETCH_N
;
5171 oldbase
= BUILT_IN_ATOMIC_FETCH_AND_N
;
5172 newbase
= BUILT_IN_ATOMIC_AND_FETCH_N
;
5175 oldbase
= BUILT_IN_ATOMIC_FETCH_OR_N
;
5176 newbase
= BUILT_IN_ATOMIC_OR_FETCH_N
;
5179 oldbase
= BUILT_IN_ATOMIC_FETCH_XOR_N
;
5180 newbase
= BUILT_IN_ATOMIC_XOR_FETCH_N
;
5186 /* Make sure the expression is of the proper form. */
5187 if (operand_equal_p (gimple_assign_rhs1 (stmt
), loaded_val
, 0))
5188 rhs
= gimple_assign_rhs2 (stmt
);
5189 else if (commutative_tree_code (gimple_assign_rhs_code (stmt
))
5190 && operand_equal_p (gimple_assign_rhs2 (stmt
), loaded_val
, 0))
5191 rhs
= gimple_assign_rhs1 (stmt
);
5195 tmpbase
= ((enum built_in_function
)
5196 ((need_new
? newbase
: oldbase
) + index
+ 1));
5197 decl
= builtin_decl_explicit (tmpbase
);
5198 if (decl
== NULL_TREE
)
5200 itype
= TREE_TYPE (TREE_TYPE (decl
));
5201 imode
= TYPE_MODE (itype
);
5203 /* We could test all of the various optabs involved, but the fact of the
5204 matter is that (with the exception of i486 vs i586 and xadd) all targets
5205 that support any atomic operaton optab also implements compare-and-swap.
5206 Let optabs.c take care of expanding any compare-and-swap loop. */
5207 if (!can_compare_and_swap_p (imode
, true))
5210 gsi
= gsi_last_bb (load_bb
);
5211 gcc_assert (gimple_code (gsi_stmt (gsi
)) == GIMPLE_OMP_ATOMIC_LOAD
);
5213 /* OpenMP does not imply any barrier-like semantics on its atomic ops.
5214 It only requires that the operation happen atomically. Thus we can
5215 use the RELAXED memory model. */
5216 call
= build_call_expr_loc (loc
, decl
, 3, addr
,
5217 fold_convert_loc (loc
, itype
, rhs
),
5218 build_int_cst (NULL
, MEMMODEL_RELAXED
));
5220 if (need_old
|| need_new
)
5222 lhs
= need_old
? loaded_val
: stored_val
;
5223 call
= fold_convert_loc (loc
, TREE_TYPE (lhs
), call
);
5224 call
= build2_loc (loc
, MODIFY_EXPR
, void_type_node
, lhs
, call
);
5227 call
= fold_convert_loc (loc
, void_type_node
, call
);
5228 force_gimple_operand_gsi (&gsi
, call
, true, NULL_TREE
, true, GSI_SAME_STMT
);
5229 gsi_remove (&gsi
, true);
5231 gsi
= gsi_last_bb (store_bb
);
5232 gcc_assert (gimple_code (gsi_stmt (gsi
)) == GIMPLE_OMP_ATOMIC_STORE
);
5233 gsi_remove (&gsi
, true);
5234 gsi
= gsi_last_bb (store_bb
);
5235 gsi_remove (&gsi
, true);
5237 if (gimple_in_ssa_p (cfun
))
5238 update_ssa (TODO_update_ssa_no_phi
);
5243 /* A subroutine of expand_omp_atomic. Implement the atomic operation as:
5247 newval = rhs; // with oldval replacing *addr in rhs
5248 oldval = __sync_val_compare_and_swap (addr, oldval, newval);
5249 if (oldval != newval)
5252 INDEX is log2 of the size of the data type, and thus usable to find the
5253 index of the builtin decl. */
5256 expand_omp_atomic_pipeline (basic_block load_bb
, basic_block store_bb
,
5257 tree addr
, tree loaded_val
, tree stored_val
,
5260 tree loadedi
, storedi
, initial
, new_storedi
, old_vali
;
5261 tree type
, itype
, cmpxchg
, iaddr
;
5262 gimple_stmt_iterator si
;
5263 basic_block loop_header
= single_succ (load_bb
);
5266 enum built_in_function fncode
;
5268 /* ??? We need a non-pointer interface to __atomic_compare_exchange in
5269 order to use the RELAXED memory model effectively. */
5270 fncode
= (enum built_in_function
)((int)BUILT_IN_SYNC_VAL_COMPARE_AND_SWAP_N
5272 cmpxchg
= builtin_decl_explicit (fncode
);
5273 if (cmpxchg
== NULL_TREE
)
5275 type
= TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (addr
)));
5276 itype
= TREE_TYPE (TREE_TYPE (cmpxchg
));
5278 if (!can_compare_and_swap_p (TYPE_MODE (itype
), true))
5281 /* Load the initial value, replacing the GIMPLE_OMP_ATOMIC_LOAD. */
5282 si
= gsi_last_bb (load_bb
);
5283 gcc_assert (gimple_code (gsi_stmt (si
)) == GIMPLE_OMP_ATOMIC_LOAD
);
5285 /* For floating-point values, we'll need to view-convert them to integers
5286 so that we can perform the atomic compare and swap. Simplify the
5287 following code by always setting up the "i"ntegral variables. */
5288 if (!INTEGRAL_TYPE_P (type
) && !POINTER_TYPE_P (type
))
5292 iaddr
= create_tmp_reg (build_pointer_type_for_mode (itype
, ptr_mode
,
5295 = force_gimple_operand_gsi (&si
,
5296 fold_convert (TREE_TYPE (iaddr
), addr
),
5297 false, NULL_TREE
, true, GSI_SAME_STMT
);
5298 stmt
= gimple_build_assign (iaddr
, iaddr_val
);
5299 gsi_insert_before (&si
, stmt
, GSI_SAME_STMT
);
5300 loadedi
= create_tmp_var (itype
, NULL
);
5301 if (gimple_in_ssa_p (cfun
))
5302 loadedi
= make_ssa_name (loadedi
, NULL
);
5307 loadedi
= loaded_val
;
5311 = force_gimple_operand_gsi (&si
,
5312 build2 (MEM_REF
, TREE_TYPE (TREE_TYPE (iaddr
)),
5314 build_int_cst (TREE_TYPE (iaddr
), 0)),
5315 true, NULL_TREE
, true, GSI_SAME_STMT
);
5317 /* Move the value to the LOADEDI temporary. */
5318 if (gimple_in_ssa_p (cfun
))
5320 gcc_assert (gimple_seq_empty_p (phi_nodes (loop_header
)));
5321 phi
= create_phi_node (loadedi
, loop_header
);
5322 SSA_NAME_DEF_STMT (loadedi
) = phi
;
5323 SET_USE (PHI_ARG_DEF_PTR_FROM_EDGE (phi
, single_succ_edge (load_bb
)),
5327 gsi_insert_before (&si
,
5328 gimple_build_assign (loadedi
, initial
),
5330 if (loadedi
!= loaded_val
)
5332 gimple_stmt_iterator gsi2
;
5335 x
= build1 (VIEW_CONVERT_EXPR
, type
, loadedi
);
5336 gsi2
= gsi_start_bb (loop_header
);
5337 if (gimple_in_ssa_p (cfun
))
5340 x
= force_gimple_operand_gsi (&gsi2
, x
, true, NULL_TREE
,
5341 true, GSI_SAME_STMT
);
5342 stmt
= gimple_build_assign (loaded_val
, x
);
5343 gsi_insert_before (&gsi2
, stmt
, GSI_SAME_STMT
);
5347 x
= build2 (MODIFY_EXPR
, TREE_TYPE (loaded_val
), loaded_val
, x
);
5348 force_gimple_operand_gsi (&gsi2
, x
, true, NULL_TREE
,
5349 true, GSI_SAME_STMT
);
5352 gsi_remove (&si
, true);
5354 si
= gsi_last_bb (store_bb
);
5355 gcc_assert (gimple_code (gsi_stmt (si
)) == GIMPLE_OMP_ATOMIC_STORE
);
5358 storedi
= stored_val
;
5361 force_gimple_operand_gsi (&si
,
5362 build1 (VIEW_CONVERT_EXPR
, itype
,
5363 stored_val
), true, NULL_TREE
, true,
5366 /* Build the compare&swap statement. */
5367 new_storedi
= build_call_expr (cmpxchg
, 3, iaddr
, loadedi
, storedi
);
5368 new_storedi
= force_gimple_operand_gsi (&si
,
5369 fold_convert (TREE_TYPE (loadedi
),
5372 true, GSI_SAME_STMT
);
5374 if (gimple_in_ssa_p (cfun
))
5378 old_vali
= create_tmp_var (TREE_TYPE (loadedi
), NULL
);
5379 stmt
= gimple_build_assign (old_vali
, loadedi
);
5380 gsi_insert_before (&si
, stmt
, GSI_SAME_STMT
);
5382 stmt
= gimple_build_assign (loadedi
, new_storedi
);
5383 gsi_insert_before (&si
, stmt
, GSI_SAME_STMT
);
5386 /* Note that we always perform the comparison as an integer, even for
5387 floating point. This allows the atomic operation to properly
5388 succeed even with NaNs and -0.0. */
5389 stmt
= gimple_build_cond_empty
5390 (build2 (NE_EXPR
, boolean_type_node
,
5391 new_storedi
, old_vali
));
5392 gsi_insert_before (&si
, stmt
, GSI_SAME_STMT
);
5395 e
= single_succ_edge (store_bb
);
5396 e
->flags
&= ~EDGE_FALLTHRU
;
5397 e
->flags
|= EDGE_FALSE_VALUE
;
5399 e
= make_edge (store_bb
, loop_header
, EDGE_TRUE_VALUE
);
5401 /* Copy the new value to loadedi (we already did that before the condition
5402 if we are not in SSA). */
5403 if (gimple_in_ssa_p (cfun
))
5405 phi
= gimple_seq_first_stmt (phi_nodes (loop_header
));
5406 SET_USE (PHI_ARG_DEF_PTR_FROM_EDGE (phi
, e
), new_storedi
);
5409 /* Remove GIMPLE_OMP_ATOMIC_STORE. */
5410 gsi_remove (&si
, true);
5412 if (gimple_in_ssa_p (cfun
))
5413 update_ssa (TODO_update_ssa_no_phi
);
5418 /* A subroutine of expand_omp_atomic. Implement the atomic operation as:
5420 GOMP_atomic_start ();
5424 The result is not globally atomic, but works so long as all parallel
5425 references are within #pragma omp atomic directives. According to
5426 responses received from omp@openmp.org, appears to be within spec.
5427 Which makes sense, since that's how several other compilers handle
5428 this situation as well.
5429 LOADED_VAL and ADDR are the operands of GIMPLE_OMP_ATOMIC_LOAD we're
5430 expanding. STORED_VAL is the operand of the matching
5431 GIMPLE_OMP_ATOMIC_STORE.
5434 GIMPLE_OMP_ATOMIC_LOAD (loaded_val, addr) with
5438 GIMPLE_OMP_ATOMIC_STORE (stored_val) with
5443 expand_omp_atomic_mutex (basic_block load_bb
, basic_block store_bb
,
5444 tree addr
, tree loaded_val
, tree stored_val
)
5446 gimple_stmt_iterator si
;
5450 si
= gsi_last_bb (load_bb
);
5451 gcc_assert (gimple_code (gsi_stmt (si
)) == GIMPLE_OMP_ATOMIC_LOAD
);
5453 t
= builtin_decl_explicit (BUILT_IN_GOMP_ATOMIC_START
);
5454 t
= build_call_expr (t
, 0);
5455 force_gimple_operand_gsi (&si
, t
, true, NULL_TREE
, true, GSI_SAME_STMT
);
5457 stmt
= gimple_build_assign (loaded_val
, build_simple_mem_ref (addr
));
5458 gsi_insert_before (&si
, stmt
, GSI_SAME_STMT
);
5459 gsi_remove (&si
, true);
5461 si
= gsi_last_bb (store_bb
);
5462 gcc_assert (gimple_code (gsi_stmt (si
)) == GIMPLE_OMP_ATOMIC_STORE
);
5464 stmt
= gimple_build_assign (build_simple_mem_ref (unshare_expr (addr
)),
5466 gsi_insert_before (&si
, stmt
, GSI_SAME_STMT
);
5468 t
= builtin_decl_explicit (BUILT_IN_GOMP_ATOMIC_END
);
5469 t
= build_call_expr (t
, 0);
5470 force_gimple_operand_gsi (&si
, t
, true, NULL_TREE
, true, GSI_SAME_STMT
);
5471 gsi_remove (&si
, true);
5473 if (gimple_in_ssa_p (cfun
))
5474 update_ssa (TODO_update_ssa_no_phi
);
5478 /* Expand an GIMPLE_OMP_ATOMIC statement. We try to expand
5479 using expand_omp_atomic_fetch_op. If it failed, we try to
5480 call expand_omp_atomic_pipeline, and if it fails too, the
5481 ultimate fallback is wrapping the operation in a mutex
5482 (expand_omp_atomic_mutex). REGION is the atomic region built
5483 by build_omp_regions_1(). */
5486 expand_omp_atomic (struct omp_region
*region
)
5488 basic_block load_bb
= region
->entry
, store_bb
= region
->exit
;
5489 gimple load
= last_stmt (load_bb
), store
= last_stmt (store_bb
);
5490 tree loaded_val
= gimple_omp_atomic_load_lhs (load
);
5491 tree addr
= gimple_omp_atomic_load_rhs (load
);
5492 tree stored_val
= gimple_omp_atomic_store_val (store
);
5493 tree type
= TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (addr
)));
5494 HOST_WIDE_INT index
;
5496 /* Make sure the type is one of the supported sizes. */
5497 index
= tree_low_cst (TYPE_SIZE_UNIT (type
), 1);
5498 index
= exact_log2 (index
);
5499 if (index
>= 0 && index
<= 4)
5501 unsigned int align
= TYPE_ALIGN_UNIT (type
);
5503 /* __sync builtins require strict data alignment. */
5504 if (exact_log2 (align
) >= index
)
5507 if (loaded_val
== stored_val
5508 && (GET_MODE_CLASS (TYPE_MODE (type
)) == MODE_INT
5509 || GET_MODE_CLASS (TYPE_MODE (type
)) == MODE_FLOAT
)
5510 && GET_MODE_BITSIZE (TYPE_MODE (type
)) <= BITS_PER_WORD
5511 && expand_omp_atomic_load (load_bb
, addr
, loaded_val
, index
))
5515 if ((GET_MODE_CLASS (TYPE_MODE (type
)) == MODE_INT
5516 || GET_MODE_CLASS (TYPE_MODE (type
)) == MODE_FLOAT
)
5517 && GET_MODE_BITSIZE (TYPE_MODE (type
)) <= BITS_PER_WORD
5518 && store_bb
== single_succ (load_bb
)
5519 && first_stmt (store_bb
) == store
5520 && expand_omp_atomic_store (load_bb
, addr
, loaded_val
,
5524 /* When possible, use specialized atomic update functions. */
5525 if ((INTEGRAL_TYPE_P (type
) || POINTER_TYPE_P (type
))
5526 && store_bb
== single_succ (load_bb
)
5527 && expand_omp_atomic_fetch_op (load_bb
, addr
,
5528 loaded_val
, stored_val
, index
))
5531 /* If we don't have specialized __sync builtins, try and implement
5532 as a compare and swap loop. */
5533 if (expand_omp_atomic_pipeline (load_bb
, store_bb
, addr
,
5534 loaded_val
, stored_val
, index
))
5539 /* The ultimate fallback is wrapping the operation in a mutex. */
5540 expand_omp_atomic_mutex (load_bb
, store_bb
, addr
, loaded_val
, stored_val
);
5544 /* Expand the parallel region tree rooted at REGION. Expansion
5545 proceeds in depth-first order. Innermost regions are expanded
5546 first. This way, parallel regions that require a new function to
5547 be created (e.g., GIMPLE_OMP_PARALLEL) can be expanded without having any
5548 internal dependencies in their body. */
5551 expand_omp (struct omp_region
*region
)
5555 location_t saved_location
;
5557 /* First, determine whether this is a combined parallel+workshare
5559 if (region
->type
== GIMPLE_OMP_PARALLEL
)
5560 determine_parallel_type (region
);
5563 expand_omp (region
->inner
);
5565 saved_location
= input_location
;
5566 if (gimple_has_location (last_stmt (region
->entry
)))
5567 input_location
= gimple_location (last_stmt (region
->entry
));
5569 switch (region
->type
)
5571 case GIMPLE_OMP_PARALLEL
:
5572 case GIMPLE_OMP_TASK
:
5573 expand_omp_taskreg (region
);
5576 case GIMPLE_OMP_FOR
:
5577 expand_omp_for (region
);
5580 case GIMPLE_OMP_SECTIONS
:
5581 expand_omp_sections (region
);
5584 case GIMPLE_OMP_SECTION
:
5585 /* Individual omp sections are handled together with their
5586 parent GIMPLE_OMP_SECTIONS region. */
5589 case GIMPLE_OMP_SINGLE
:
5590 expand_omp_single (region
);
5593 case GIMPLE_OMP_MASTER
:
5594 case GIMPLE_OMP_ORDERED
:
5595 case GIMPLE_OMP_CRITICAL
:
5596 expand_omp_synch (region
);
5599 case GIMPLE_OMP_ATOMIC_LOAD
:
5600 expand_omp_atomic (region
);
5607 input_location
= saved_location
;
5608 region
= region
->next
;
5613 /* Helper for build_omp_regions. Scan the dominator tree starting at
5614 block BB. PARENT is the region that contains BB. If SINGLE_TREE is
5615 true, the function ends once a single tree is built (otherwise, whole
5616 forest of OMP constructs may be built). */
5619 build_omp_regions_1 (basic_block bb
, struct omp_region
*parent
,
5622 gimple_stmt_iterator gsi
;
5626 gsi
= gsi_last_bb (bb
);
5627 if (!gsi_end_p (gsi
) && is_gimple_omp (gsi_stmt (gsi
)))
5629 struct omp_region
*region
;
5630 enum gimple_code code
;
5632 stmt
= gsi_stmt (gsi
);
5633 code
= gimple_code (stmt
);
5634 if (code
== GIMPLE_OMP_RETURN
)
5636 /* STMT is the return point out of region PARENT. Mark it
5637 as the exit point and make PARENT the immediately
5638 enclosing region. */
5639 gcc_assert (parent
);
5642 parent
= parent
->outer
;
5644 else if (code
== GIMPLE_OMP_ATOMIC_STORE
)
5646 /* GIMPLE_OMP_ATOMIC_STORE is analoguous to
5647 GIMPLE_OMP_RETURN, but matches with
5648 GIMPLE_OMP_ATOMIC_LOAD. */
5649 gcc_assert (parent
);
5650 gcc_assert (parent
->type
== GIMPLE_OMP_ATOMIC_LOAD
);
5653 parent
= parent
->outer
;
5656 else if (code
== GIMPLE_OMP_CONTINUE
)
5658 gcc_assert (parent
);
5661 else if (code
== GIMPLE_OMP_SECTIONS_SWITCH
)
5663 /* GIMPLE_OMP_SECTIONS_SWITCH is part of
5664 GIMPLE_OMP_SECTIONS, and we do nothing for it. */
5669 /* Otherwise, this directive becomes the parent for a new
5671 region
= new_omp_region (bb
, code
, parent
);
5676 if (single_tree
&& !parent
)
5679 for (son
= first_dom_son (CDI_DOMINATORS
, bb
);
5681 son
= next_dom_son (CDI_DOMINATORS
, son
))
5682 build_omp_regions_1 (son
, parent
, single_tree
);
5685 /* Builds the tree of OMP regions rooted at ROOT, storing it to
5689 build_omp_regions_root (basic_block root
)
5691 gcc_assert (root_omp_region
== NULL
);
5692 build_omp_regions_1 (root
, NULL
, true);
5693 gcc_assert (root_omp_region
!= NULL
);
5696 /* Expands omp construct (and its subconstructs) starting in HEAD. */
5699 omp_expand_local (basic_block head
)
5701 build_omp_regions_root (head
);
5702 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
5704 fprintf (dump_file
, "\nOMP region tree\n\n");
5705 dump_omp_region (dump_file
, root_omp_region
, 0);
5706 fprintf (dump_file
, "\n");
5709 remove_exit_barriers (root_omp_region
);
5710 expand_omp (root_omp_region
);
5712 free_omp_regions ();
5715 /* Scan the CFG and build a tree of OMP regions. Return the root of
5716 the OMP region tree. */
5719 build_omp_regions (void)
5721 gcc_assert (root_omp_region
== NULL
);
5722 calculate_dominance_info (CDI_DOMINATORS
);
5723 build_omp_regions_1 (ENTRY_BLOCK_PTR
, NULL
, false);
5726 /* Main entry point for expanding OMP-GIMPLE into runtime calls. */
5729 execute_expand_omp (void)
5731 build_omp_regions ();
5733 if (!root_omp_region
)
5738 fprintf (dump_file
, "\nOMP region tree\n\n");
5739 dump_omp_region (dump_file
, root_omp_region
, 0);
5740 fprintf (dump_file
, "\n");
5743 remove_exit_barriers (root_omp_region
);
5745 expand_omp (root_omp_region
);
5747 cleanup_tree_cfg ();
5749 free_omp_regions ();
5754 /* OMP expansion -- the default pass, run before creation of SSA form. */
5757 gate_expand_omp (void)
5759 return (flag_openmp
!= 0 && !seen_error ());
5762 struct gimple_opt_pass pass_expand_omp
=
5766 "ompexp", /* name */
5767 gate_expand_omp
, /* gate */
5768 execute_expand_omp
, /* execute */
5771 0, /* static_pass_number */
5772 TV_NONE
, /* tv_id */
5773 PROP_gimple_any
, /* properties_required */
5774 0, /* properties_provided */
5775 0, /* properties_destroyed */
5776 0, /* todo_flags_start */
5777 0 /* todo_flags_finish */
5781 /* Routines to lower OpenMP directives into OMP-GIMPLE. */
5783 /* Lower the OpenMP sections directive in the current statement in GSI_P.
5784 CTX is the enclosing OMP context for the current statement. */
5787 lower_omp_sections (gimple_stmt_iterator
*gsi_p
, omp_context
*ctx
)
5789 tree block
, control
;
5790 gimple_stmt_iterator tgsi
;
5791 gimple stmt
, new_stmt
, bind
, t
;
5792 gimple_seq ilist
, dlist
, olist
, new_body
;
5793 struct gimplify_ctx gctx
;
5795 stmt
= gsi_stmt (*gsi_p
);
5797 push_gimplify_context (&gctx
);
5801 lower_rec_input_clauses (gimple_omp_sections_clauses (stmt
),
5802 &ilist
, &dlist
, ctx
);
5804 new_body
= gimple_omp_body (stmt
);
5805 gimple_omp_set_body (stmt
, NULL
);
5806 tgsi
= gsi_start (new_body
);
5807 for (; !gsi_end_p (tgsi
); gsi_next (&tgsi
))
5812 sec_start
= gsi_stmt (tgsi
);
5813 sctx
= maybe_lookup_ctx (sec_start
);
5816 lower_omp (gimple_omp_body_ptr (sec_start
), sctx
);
5817 gsi_insert_seq_after (&tgsi
, gimple_omp_body (sec_start
),
5818 GSI_CONTINUE_LINKING
);
5819 gimple_omp_set_body (sec_start
, NULL
);
5821 if (gsi_one_before_end_p (tgsi
))
5823 gimple_seq l
= NULL
;
5824 lower_lastprivate_clauses (gimple_omp_sections_clauses (stmt
), NULL
,
5826 gsi_insert_seq_after (&tgsi
, l
, GSI_CONTINUE_LINKING
);
5827 gimple_omp_section_set_last (sec_start
);
5830 gsi_insert_after (&tgsi
, gimple_build_omp_return (false),
5831 GSI_CONTINUE_LINKING
);
5834 block
= make_node (BLOCK
);
5835 bind
= gimple_build_bind (NULL
, new_body
, block
);
5838 lower_reduction_clauses (gimple_omp_sections_clauses (stmt
), &olist
, ctx
);
5840 block
= make_node (BLOCK
);
5841 new_stmt
= gimple_build_bind (NULL
, NULL
, block
);
5842 gsi_replace (gsi_p
, new_stmt
, true);
5844 pop_gimplify_context (new_stmt
);
5845 gimple_bind_append_vars (new_stmt
, ctx
->block_vars
);
5846 BLOCK_VARS (block
) = gimple_bind_vars (bind
);
5847 if (BLOCK_VARS (block
))
5848 TREE_USED (block
) = 1;
5851 gimple_seq_add_seq (&new_body
, ilist
);
5852 gimple_seq_add_stmt (&new_body
, stmt
);
5853 gimple_seq_add_stmt (&new_body
, gimple_build_omp_sections_switch ());
5854 gimple_seq_add_stmt (&new_body
, bind
);
5856 control
= create_tmp_var (unsigned_type_node
, ".section");
5857 t
= gimple_build_omp_continue (control
, control
);
5858 gimple_omp_sections_set_control (stmt
, control
);
5859 gimple_seq_add_stmt (&new_body
, t
);
5861 gimple_seq_add_seq (&new_body
, olist
);
5862 gimple_seq_add_seq (&new_body
, dlist
);
5864 new_body
= maybe_catch_exception (new_body
);
5866 t
= gimple_build_omp_return
5867 (!!find_omp_clause (gimple_omp_sections_clauses (stmt
),
5868 OMP_CLAUSE_NOWAIT
));
5869 gimple_seq_add_stmt (&new_body
, t
);
5871 gimple_bind_set_body (new_stmt
, new_body
);
5875 /* A subroutine of lower_omp_single. Expand the simple form of
5876 a GIMPLE_OMP_SINGLE, without a copyprivate clause:
5878 if (GOMP_single_start ())
5880 [ GOMP_barrier (); ] -> unless 'nowait' is present.
5882 FIXME. It may be better to delay expanding the logic of this until
5883 pass_expand_omp. The expanded logic may make the job more difficult
5884 to a synchronization analysis pass. */
5887 lower_omp_single_simple (gimple single_stmt
, gimple_seq
*pre_p
)
5889 location_t loc
= gimple_location (single_stmt
);
5890 tree tlabel
= create_artificial_label (loc
);
5891 tree flabel
= create_artificial_label (loc
);
5895 decl
= builtin_decl_explicit (BUILT_IN_GOMP_SINGLE_START
);
5896 lhs
= create_tmp_var (TREE_TYPE (TREE_TYPE (decl
)), NULL
);
5897 call
= gimple_build_call (decl
, 0);
5898 gimple_call_set_lhs (call
, lhs
);
5899 gimple_seq_add_stmt (pre_p
, call
);
5901 cond
= gimple_build_cond (EQ_EXPR
, lhs
,
5902 fold_convert_loc (loc
, TREE_TYPE (lhs
),
5905 gimple_seq_add_stmt (pre_p
, cond
);
5906 gimple_seq_add_stmt (pre_p
, gimple_build_label (tlabel
));
5907 gimple_seq_add_seq (pre_p
, gimple_omp_body (single_stmt
));
5908 gimple_seq_add_stmt (pre_p
, gimple_build_label (flabel
));
5912 /* A subroutine of lower_omp_single. Expand the simple form of
5913 a GIMPLE_OMP_SINGLE, with a copyprivate clause:
5915 #pragma omp single copyprivate (a, b, c)
5917 Create a new structure to hold copies of 'a', 'b' and 'c' and emit:
5920 if ((copyout_p = GOMP_single_copy_start ()) == NULL)
5926 GOMP_single_copy_end (©out);
5937 FIXME. It may be better to delay expanding the logic of this until
5938 pass_expand_omp. The expanded logic may make the job more difficult
5939 to a synchronization analysis pass. */
5942 lower_omp_single_copy (gimple single_stmt
, gimple_seq
*pre_p
, omp_context
*ctx
)
5944 tree ptr_type
, t
, l0
, l1
, l2
, bfn_decl
;
5945 gimple_seq copyin_seq
;
5946 location_t loc
= gimple_location (single_stmt
);
5948 ctx
->sender_decl
= create_tmp_var (ctx
->record_type
, ".omp_copy_o");
5950 ptr_type
= build_pointer_type (ctx
->record_type
);
5951 ctx
->receiver_decl
= create_tmp_var (ptr_type
, ".omp_copy_i");
5953 l0
= create_artificial_label (loc
);
5954 l1
= create_artificial_label (loc
);
5955 l2
= create_artificial_label (loc
);
5957 bfn_decl
= builtin_decl_explicit (BUILT_IN_GOMP_SINGLE_COPY_START
);
5958 t
= build_call_expr_loc (loc
, bfn_decl
, 0);
5959 t
= fold_convert_loc (loc
, ptr_type
, t
);
5960 gimplify_assign (ctx
->receiver_decl
, t
, pre_p
);
5962 t
= build2 (EQ_EXPR
, boolean_type_node
, ctx
->receiver_decl
,
5963 build_int_cst (ptr_type
, 0));
5964 t
= build3 (COND_EXPR
, void_type_node
, t
,
5965 build_and_jump (&l0
), build_and_jump (&l1
));
5966 gimplify_and_add (t
, pre_p
);
5968 gimple_seq_add_stmt (pre_p
, gimple_build_label (l0
));
5970 gimple_seq_add_seq (pre_p
, gimple_omp_body (single_stmt
));
5973 lower_copyprivate_clauses (gimple_omp_single_clauses (single_stmt
), pre_p
,
5976 t
= build_fold_addr_expr_loc (loc
, ctx
->sender_decl
);
5977 bfn_decl
= builtin_decl_explicit (BUILT_IN_GOMP_SINGLE_COPY_END
);
5978 t
= build_call_expr_loc (loc
, bfn_decl
, 1, t
);
5979 gimplify_and_add (t
, pre_p
);
5981 t
= build_and_jump (&l2
);
5982 gimplify_and_add (t
, pre_p
);
5984 gimple_seq_add_stmt (pre_p
, gimple_build_label (l1
));
5986 gimple_seq_add_seq (pre_p
, copyin_seq
);
5988 gimple_seq_add_stmt (pre_p
, gimple_build_label (l2
));
5992 /* Expand code for an OpenMP single directive. */
5995 lower_omp_single (gimple_stmt_iterator
*gsi_p
, omp_context
*ctx
)
5998 gimple t
, bind
, single_stmt
= gsi_stmt (*gsi_p
);
5999 gimple_seq bind_body
, dlist
;
6000 struct gimplify_ctx gctx
;
6002 push_gimplify_context (&gctx
);
6004 block
= make_node (BLOCK
);
6005 bind
= gimple_build_bind (NULL
, NULL
, block
);
6006 gsi_replace (gsi_p
, bind
, true);
6009 lower_rec_input_clauses (gimple_omp_single_clauses (single_stmt
),
6010 &bind_body
, &dlist
, ctx
);
6011 lower_omp (gimple_omp_body_ptr (single_stmt
), ctx
);
6013 gimple_seq_add_stmt (&bind_body
, single_stmt
);
6015 if (ctx
->record_type
)
6016 lower_omp_single_copy (single_stmt
, &bind_body
, ctx
);
6018 lower_omp_single_simple (single_stmt
, &bind_body
);
6020 gimple_omp_set_body (single_stmt
, NULL
);
6022 gimple_seq_add_seq (&bind_body
, dlist
);
6024 bind_body
= maybe_catch_exception (bind_body
);
6026 t
= gimple_build_omp_return
6027 (!!find_omp_clause (gimple_omp_single_clauses (single_stmt
),
6028 OMP_CLAUSE_NOWAIT
));
6029 gimple_seq_add_stmt (&bind_body
, t
);
6030 gimple_bind_set_body (bind
, bind_body
);
6032 pop_gimplify_context (bind
);
6034 gimple_bind_append_vars (bind
, ctx
->block_vars
);
6035 BLOCK_VARS (block
) = ctx
->block_vars
;
6036 if (BLOCK_VARS (block
))
6037 TREE_USED (block
) = 1;
6041 /* Expand code for an OpenMP master directive. */
6044 lower_omp_master (gimple_stmt_iterator
*gsi_p
, omp_context
*ctx
)
6046 tree block
, lab
= NULL
, x
, bfn_decl
;
6047 gimple stmt
= gsi_stmt (*gsi_p
), bind
;
6048 location_t loc
= gimple_location (stmt
);
6050 struct gimplify_ctx gctx
;
6052 push_gimplify_context (&gctx
);
6054 block
= make_node (BLOCK
);
6055 bind
= gimple_build_bind (NULL
, NULL
, block
);
6056 gsi_replace (gsi_p
, bind
, true);
6057 gimple_bind_add_stmt (bind
, stmt
);
6059 bfn_decl
= builtin_decl_explicit (BUILT_IN_OMP_GET_THREAD_NUM
);
6060 x
= build_call_expr_loc (loc
, bfn_decl
, 0);
6061 x
= build2 (EQ_EXPR
, boolean_type_node
, x
, integer_zero_node
);
6062 x
= build3 (COND_EXPR
, void_type_node
, x
, NULL
, build_and_jump (&lab
));
6064 gimplify_and_add (x
, &tseq
);
6065 gimple_bind_add_seq (bind
, tseq
);
6067 lower_omp (gimple_omp_body_ptr (stmt
), ctx
);
6068 gimple_omp_set_body (stmt
, maybe_catch_exception (gimple_omp_body (stmt
)));
6069 gimple_bind_add_seq (bind
, gimple_omp_body (stmt
));
6070 gimple_omp_set_body (stmt
, NULL
);
6072 gimple_bind_add_stmt (bind
, gimple_build_label (lab
));
6074 gimple_bind_add_stmt (bind
, gimple_build_omp_return (true));
6076 pop_gimplify_context (bind
);
6078 gimple_bind_append_vars (bind
, ctx
->block_vars
);
6079 BLOCK_VARS (block
) = ctx
->block_vars
;
6083 /* Expand code for an OpenMP ordered directive. */
6086 lower_omp_ordered (gimple_stmt_iterator
*gsi_p
, omp_context
*ctx
)
6089 gimple stmt
= gsi_stmt (*gsi_p
), bind
, x
;
6090 struct gimplify_ctx gctx
;
6092 push_gimplify_context (&gctx
);
6094 block
= make_node (BLOCK
);
6095 bind
= gimple_build_bind (NULL
, NULL
, block
);
6096 gsi_replace (gsi_p
, bind
, true);
6097 gimple_bind_add_stmt (bind
, stmt
);
6099 x
= gimple_build_call (builtin_decl_explicit (BUILT_IN_GOMP_ORDERED_START
),
6101 gimple_bind_add_stmt (bind
, x
);
6103 lower_omp (gimple_omp_body_ptr (stmt
), ctx
);
6104 gimple_omp_set_body (stmt
, maybe_catch_exception (gimple_omp_body (stmt
)));
6105 gimple_bind_add_seq (bind
, gimple_omp_body (stmt
));
6106 gimple_omp_set_body (stmt
, NULL
);
6108 x
= gimple_build_call (builtin_decl_explicit (BUILT_IN_GOMP_ORDERED_END
), 0);
6109 gimple_bind_add_stmt (bind
, x
);
6111 gimple_bind_add_stmt (bind
, gimple_build_omp_return (true));
6113 pop_gimplify_context (bind
);
6115 gimple_bind_append_vars (bind
, ctx
->block_vars
);
6116 BLOCK_VARS (block
) = gimple_bind_vars (bind
);
6120 /* Gimplify a GIMPLE_OMP_CRITICAL statement. This is a relatively simple
6121 substitution of a couple of function calls. But in the NAMED case,
6122 requires that languages coordinate a symbol name. It is therefore
6123 best put here in common code. */
6125 static GTY((param1_is (tree
), param2_is (tree
)))
6126 splay_tree critical_name_mutexes
;
6129 lower_omp_critical (gimple_stmt_iterator
*gsi_p
, omp_context
*ctx
)
6132 tree name
, lock
, unlock
;
6133 gimple stmt
= gsi_stmt (*gsi_p
), bind
;
6134 location_t loc
= gimple_location (stmt
);
6136 struct gimplify_ctx gctx
;
6138 name
= gimple_omp_critical_name (stmt
);
6144 if (!critical_name_mutexes
)
6145 critical_name_mutexes
6146 = splay_tree_new_ggc (splay_tree_compare_pointers
,
6147 ggc_alloc_splay_tree_tree_node_tree_node_splay_tree_s
,
6148 ggc_alloc_splay_tree_tree_node_tree_node_splay_tree_node_s
);
6150 n
= splay_tree_lookup (critical_name_mutexes
, (splay_tree_key
) name
);
6155 decl
= create_tmp_var_raw (ptr_type_node
, NULL
);
6157 new_str
= ACONCAT ((".gomp_critical_user_",
6158 IDENTIFIER_POINTER (name
), NULL
));
6159 DECL_NAME (decl
) = get_identifier (new_str
);
6160 TREE_PUBLIC (decl
) = 1;
6161 TREE_STATIC (decl
) = 1;
6162 DECL_COMMON (decl
) = 1;
6163 DECL_ARTIFICIAL (decl
) = 1;
6164 DECL_IGNORED_P (decl
) = 1;
6165 varpool_finalize_decl (decl
);
6167 splay_tree_insert (critical_name_mutexes
, (splay_tree_key
) name
,
6168 (splay_tree_value
) decl
);
6171 decl
= (tree
) n
->value
;
6173 lock
= builtin_decl_explicit (BUILT_IN_GOMP_CRITICAL_NAME_START
);
6174 lock
= build_call_expr_loc (loc
, lock
, 1, build_fold_addr_expr_loc (loc
, decl
));
6176 unlock
= builtin_decl_explicit (BUILT_IN_GOMP_CRITICAL_NAME_END
);
6177 unlock
= build_call_expr_loc (loc
, unlock
, 1,
6178 build_fold_addr_expr_loc (loc
, decl
));
6182 lock
= builtin_decl_explicit (BUILT_IN_GOMP_CRITICAL_START
);
6183 lock
= build_call_expr_loc (loc
, lock
, 0);
6185 unlock
= builtin_decl_explicit (BUILT_IN_GOMP_CRITICAL_END
);
6186 unlock
= build_call_expr_loc (loc
, unlock
, 0);
6189 push_gimplify_context (&gctx
);
6191 block
= make_node (BLOCK
);
6192 bind
= gimple_build_bind (NULL
, NULL
, block
);
6193 gsi_replace (gsi_p
, bind
, true);
6194 gimple_bind_add_stmt (bind
, stmt
);
6196 tbody
= gimple_bind_body (bind
);
6197 gimplify_and_add (lock
, &tbody
);
6198 gimple_bind_set_body (bind
, tbody
);
6200 lower_omp (gimple_omp_body_ptr (stmt
), ctx
);
6201 gimple_omp_set_body (stmt
, maybe_catch_exception (gimple_omp_body (stmt
)));
6202 gimple_bind_add_seq (bind
, gimple_omp_body (stmt
));
6203 gimple_omp_set_body (stmt
, NULL
);
6205 tbody
= gimple_bind_body (bind
);
6206 gimplify_and_add (unlock
, &tbody
);
6207 gimple_bind_set_body (bind
, tbody
);
6209 gimple_bind_add_stmt (bind
, gimple_build_omp_return (true));
6211 pop_gimplify_context (bind
);
6212 gimple_bind_append_vars (bind
, ctx
->block_vars
);
6213 BLOCK_VARS (block
) = gimple_bind_vars (bind
);
6217 /* A subroutine of lower_omp_for. Generate code to emit the predicate
6218 for a lastprivate clause. Given a loop control predicate of (V
6219 cond N2), we gate the clause on (!(V cond N2)). The lowered form
6220 is appended to *DLIST, iterator initialization is appended to
6224 lower_omp_for_lastprivate (struct omp_for_data
*fd
, gimple_seq
*body_p
,
6225 gimple_seq
*dlist
, struct omp_context
*ctx
)
6227 tree clauses
, cond
, vinit
;
6228 enum tree_code cond_code
;
6231 cond_code
= fd
->loop
.cond_code
;
6232 cond_code
= cond_code
== LT_EXPR
? GE_EXPR
: LE_EXPR
;
6234 /* When possible, use a strict equality expression. This can let VRP
6235 type optimizations deduce the value and remove a copy. */
6236 if (host_integerp (fd
->loop
.step
, 0))
6238 HOST_WIDE_INT step
= TREE_INT_CST_LOW (fd
->loop
.step
);
6239 if (step
== 1 || step
== -1)
6240 cond_code
= EQ_EXPR
;
6243 cond
= build2 (cond_code
, boolean_type_node
, fd
->loop
.v
, fd
->loop
.n2
);
6245 clauses
= gimple_omp_for_clauses (fd
->for_stmt
);
6247 lower_lastprivate_clauses (clauses
, cond
, &stmts
, ctx
);
6248 if (!gimple_seq_empty_p (stmts
))
6250 gimple_seq_add_seq (&stmts
, *dlist
);
6253 /* Optimize: v = 0; is usually cheaper than v = some_other_constant. */
6254 vinit
= fd
->loop
.n1
;
6255 if (cond_code
== EQ_EXPR
6256 && host_integerp (fd
->loop
.n2
, 0)
6257 && ! integer_zerop (fd
->loop
.n2
))
6258 vinit
= build_int_cst (TREE_TYPE (fd
->loop
.v
), 0);
6260 /* Initialize the iterator variable, so that threads that don't execute
6261 any iterations don't execute the lastprivate clauses by accident. */
6262 gimplify_assign (fd
->loop
.v
, vinit
, body_p
);
6267 /* Lower code for an OpenMP loop directive. */
6270 lower_omp_for (gimple_stmt_iterator
*gsi_p
, omp_context
*ctx
)
6273 struct omp_for_data fd
;
6274 gimple stmt
= gsi_stmt (*gsi_p
), new_stmt
;
6275 gimple_seq omp_for_body
, body
, dlist
;
6277 struct gimplify_ctx gctx
;
6279 push_gimplify_context (&gctx
);
6281 lower_omp (gimple_omp_for_pre_body_ptr (stmt
), ctx
);
6282 lower_omp (gimple_omp_body_ptr (stmt
), ctx
);
6284 block
= make_node (BLOCK
);
6285 new_stmt
= gimple_build_bind (NULL
, NULL
, block
);
6286 /* Replace at gsi right away, so that 'stmt' is no member
6287 of a sequence anymore as we're going to add to to a different
6289 gsi_replace (gsi_p
, new_stmt
, true);
6291 /* Move declaration of temporaries in the loop body before we make
6293 omp_for_body
= gimple_omp_body (stmt
);
6294 if (!gimple_seq_empty_p (omp_for_body
)
6295 && gimple_code (gimple_seq_first_stmt (omp_for_body
)) == GIMPLE_BIND
)
6297 tree vars
= gimple_bind_vars (gimple_seq_first_stmt (omp_for_body
));
6298 gimple_bind_append_vars (new_stmt
, vars
);
6301 /* The pre-body and input clauses go before the lowered GIMPLE_OMP_FOR. */
6304 lower_rec_input_clauses (gimple_omp_for_clauses (stmt
), &body
, &dlist
, ctx
);
6305 gimple_seq_add_seq (&body
, gimple_omp_for_pre_body (stmt
));
6307 /* Lower the header expressions. At this point, we can assume that
6308 the header is of the form:
6310 #pragma omp for (V = VAL1; V {<|>|<=|>=} VAL2; V = V [+-] VAL3)
6312 We just need to make sure that VAL1, VAL2 and VAL3 are lowered
6313 using the .omp_data_s mapping, if needed. */
6314 for (i
= 0; i
< gimple_omp_for_collapse (stmt
); i
++)
6316 rhs_p
= gimple_omp_for_initial_ptr (stmt
, i
);
6317 if (!is_gimple_min_invariant (*rhs_p
))
6318 *rhs_p
= get_formal_tmp_var (*rhs_p
, &body
);
6320 rhs_p
= gimple_omp_for_final_ptr (stmt
, i
);
6321 if (!is_gimple_min_invariant (*rhs_p
))
6322 *rhs_p
= get_formal_tmp_var (*rhs_p
, &body
);
6324 rhs_p
= &TREE_OPERAND (gimple_omp_for_incr (stmt
, i
), 1);
6325 if (!is_gimple_min_invariant (*rhs_p
))
6326 *rhs_p
= get_formal_tmp_var (*rhs_p
, &body
);
6329 /* Once lowered, extract the bounds and clauses. */
6330 extract_omp_for_data (stmt
, &fd
, NULL
);
6332 lower_omp_for_lastprivate (&fd
, &body
, &dlist
, ctx
);
6334 gimple_seq_add_stmt (&body
, stmt
);
6335 gimple_seq_add_seq (&body
, gimple_omp_body (stmt
));
6337 gimple_seq_add_stmt (&body
, gimple_build_omp_continue (fd
.loop
.v
,
6340 /* After the loop, add exit clauses. */
6341 lower_reduction_clauses (gimple_omp_for_clauses (stmt
), &body
, ctx
);
6342 gimple_seq_add_seq (&body
, dlist
);
6344 body
= maybe_catch_exception (body
);
6346 /* Region exit marker goes at the end of the loop body. */
6347 gimple_seq_add_stmt (&body
, gimple_build_omp_return (fd
.have_nowait
));
6349 pop_gimplify_context (new_stmt
);
6351 gimple_bind_append_vars (new_stmt
, ctx
->block_vars
);
6352 BLOCK_VARS (block
) = gimple_bind_vars (new_stmt
);
6353 if (BLOCK_VARS (block
))
6354 TREE_USED (block
) = 1;
6356 gimple_bind_set_body (new_stmt
, body
);
6357 gimple_omp_set_body (stmt
, NULL
);
6358 gimple_omp_for_set_pre_body (stmt
, NULL
);
6361 /* Callback for walk_stmts. Check if the current statement only contains
6362 GIMPLE_OMP_FOR or GIMPLE_OMP_PARALLEL. */
6365 check_combined_parallel (gimple_stmt_iterator
*gsi_p
,
6366 bool *handled_ops_p
,
6367 struct walk_stmt_info
*wi
)
6369 int *info
= (int *) wi
->info
;
6370 gimple stmt
= gsi_stmt (*gsi_p
);
6372 *handled_ops_p
= true;
6373 switch (gimple_code (stmt
))
6377 case GIMPLE_OMP_FOR
:
6378 case GIMPLE_OMP_SECTIONS
:
6379 *info
= *info
== 0 ? 1 : -1;
6388 struct omp_taskcopy_context
6390 /* This field must be at the beginning, as we do "inheritance": Some
6391 callback functions for tree-inline.c (e.g., omp_copy_decl)
6392 receive a copy_body_data pointer that is up-casted to an
6393 omp_context pointer. */
6399 task_copyfn_copy_decl (tree var
, copy_body_data
*cb
)
6401 struct omp_taskcopy_context
*tcctx
= (struct omp_taskcopy_context
*) cb
;
6403 if (splay_tree_lookup (tcctx
->ctx
->sfield_map
, (splay_tree_key
) var
))
6404 return create_tmp_var (TREE_TYPE (var
), NULL
);
6410 task_copyfn_remap_type (struct omp_taskcopy_context
*tcctx
, tree orig_type
)
6412 tree name
, new_fields
= NULL
, type
, f
;
6414 type
= lang_hooks
.types
.make_type (RECORD_TYPE
);
6415 name
= DECL_NAME (TYPE_NAME (orig_type
));
6416 name
= build_decl (gimple_location (tcctx
->ctx
->stmt
),
6417 TYPE_DECL
, name
, type
);
6418 TYPE_NAME (type
) = name
;
6420 for (f
= TYPE_FIELDS (orig_type
); f
; f
= TREE_CHAIN (f
))
6422 tree new_f
= copy_node (f
);
6423 DECL_CONTEXT (new_f
) = type
;
6424 TREE_TYPE (new_f
) = remap_type (TREE_TYPE (f
), &tcctx
->cb
);
6425 TREE_CHAIN (new_f
) = new_fields
;
6426 walk_tree (&DECL_SIZE (new_f
), copy_tree_body_r
, &tcctx
->cb
, NULL
);
6427 walk_tree (&DECL_SIZE_UNIT (new_f
), copy_tree_body_r
, &tcctx
->cb
, NULL
);
6428 walk_tree (&DECL_FIELD_OFFSET (new_f
), copy_tree_body_r
,
6431 *pointer_map_insert (tcctx
->cb
.decl_map
, f
) = new_f
;
6433 TYPE_FIELDS (type
) = nreverse (new_fields
);
6438 /* Create task copyfn. */
6441 create_task_copyfn (gimple task_stmt
, omp_context
*ctx
)
6443 struct function
*child_cfun
;
6444 tree child_fn
, t
, c
, src
, dst
, f
, sf
, arg
, sarg
, decl
;
6445 tree record_type
, srecord_type
, bind
, list
;
6446 bool record_needs_remap
= false, srecord_needs_remap
= false;
6448 struct omp_taskcopy_context tcctx
;
6449 struct gimplify_ctx gctx
;
6450 location_t loc
= gimple_location (task_stmt
);
6452 child_fn
= gimple_omp_task_copy_fn (task_stmt
);
6453 child_cfun
= DECL_STRUCT_FUNCTION (child_fn
);
6454 gcc_assert (child_cfun
->cfg
== NULL
);
6455 DECL_SAVED_TREE (child_fn
) = alloc_stmt_list ();
6457 /* Reset DECL_CONTEXT on function arguments. */
6458 for (t
= DECL_ARGUMENTS (child_fn
); t
; t
= DECL_CHAIN (t
))
6459 DECL_CONTEXT (t
) = child_fn
;
6461 /* Populate the function. */
6462 push_gimplify_context (&gctx
);
6463 current_function_decl
= child_fn
;
6465 bind
= build3 (BIND_EXPR
, void_type_node
, NULL
, NULL
, NULL
);
6466 TREE_SIDE_EFFECTS (bind
) = 1;
6468 DECL_SAVED_TREE (child_fn
) = bind
;
6469 DECL_SOURCE_LOCATION (child_fn
) = gimple_location (task_stmt
);
6471 /* Remap src and dst argument types if needed. */
6472 record_type
= ctx
->record_type
;
6473 srecord_type
= ctx
->srecord_type
;
6474 for (f
= TYPE_FIELDS (record_type
); f
; f
= DECL_CHAIN (f
))
6475 if (variably_modified_type_p (TREE_TYPE (f
), ctx
->cb
.src_fn
))
6477 record_needs_remap
= true;
6480 for (f
= TYPE_FIELDS (srecord_type
); f
; f
= DECL_CHAIN (f
))
6481 if (variably_modified_type_p (TREE_TYPE (f
), ctx
->cb
.src_fn
))
6483 srecord_needs_remap
= true;
6487 if (record_needs_remap
|| srecord_needs_remap
)
6489 memset (&tcctx
, '\0', sizeof (tcctx
));
6490 tcctx
.cb
.src_fn
= ctx
->cb
.src_fn
;
6491 tcctx
.cb
.dst_fn
= child_fn
;
6492 tcctx
.cb
.src_node
= cgraph_get_node (tcctx
.cb
.src_fn
);
6493 gcc_checking_assert (tcctx
.cb
.src_node
);
6494 tcctx
.cb
.dst_node
= tcctx
.cb
.src_node
;
6495 tcctx
.cb
.src_cfun
= ctx
->cb
.src_cfun
;
6496 tcctx
.cb
.copy_decl
= task_copyfn_copy_decl
;
6497 tcctx
.cb
.eh_lp_nr
= 0;
6498 tcctx
.cb
.transform_call_graph_edges
= CB_CGE_MOVE
;
6499 tcctx
.cb
.decl_map
= pointer_map_create ();
6502 if (record_needs_remap
)
6503 record_type
= task_copyfn_remap_type (&tcctx
, record_type
);
6504 if (srecord_needs_remap
)
6505 srecord_type
= task_copyfn_remap_type (&tcctx
, srecord_type
);
6508 tcctx
.cb
.decl_map
= NULL
;
6510 push_cfun (child_cfun
);
6512 arg
= DECL_ARGUMENTS (child_fn
);
6513 TREE_TYPE (arg
) = build_pointer_type (record_type
);
6514 sarg
= DECL_CHAIN (arg
);
6515 TREE_TYPE (sarg
) = build_pointer_type (srecord_type
);
6517 /* First pass: initialize temporaries used in record_type and srecord_type
6518 sizes and field offsets. */
6519 if (tcctx
.cb
.decl_map
)
6520 for (c
= gimple_omp_task_clauses (task_stmt
); c
; c
= OMP_CLAUSE_CHAIN (c
))
6521 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_FIRSTPRIVATE
)
6525 decl
= OMP_CLAUSE_DECL (c
);
6526 p
= (tree
*) pointer_map_contains (tcctx
.cb
.decl_map
, decl
);
6529 n
= splay_tree_lookup (ctx
->sfield_map
, (splay_tree_key
) decl
);
6530 sf
= (tree
) n
->value
;
6531 sf
= *(tree
*) pointer_map_contains (tcctx
.cb
.decl_map
, sf
);
6532 src
= build_simple_mem_ref_loc (loc
, sarg
);
6533 src
= omp_build_component_ref (src
, sf
);
6534 t
= build2 (MODIFY_EXPR
, TREE_TYPE (*p
), *p
, src
);
6535 append_to_statement_list (t
, &list
);
6538 /* Second pass: copy shared var pointers and copy construct non-VLA
6539 firstprivate vars. */
6540 for (c
= gimple_omp_task_clauses (task_stmt
); c
; c
= OMP_CLAUSE_CHAIN (c
))
6541 switch (OMP_CLAUSE_CODE (c
))
6543 case OMP_CLAUSE_SHARED
:
6544 decl
= OMP_CLAUSE_DECL (c
);
6545 n
= splay_tree_lookup (ctx
->field_map
, (splay_tree_key
) decl
);
6548 f
= (tree
) n
->value
;
6549 if (tcctx
.cb
.decl_map
)
6550 f
= *(tree
*) pointer_map_contains (tcctx
.cb
.decl_map
, f
);
6551 n
= splay_tree_lookup (ctx
->sfield_map
, (splay_tree_key
) decl
);
6552 sf
= (tree
) n
->value
;
6553 if (tcctx
.cb
.decl_map
)
6554 sf
= *(tree
*) pointer_map_contains (tcctx
.cb
.decl_map
, sf
);
6555 src
= build_simple_mem_ref_loc (loc
, sarg
);
6556 src
= omp_build_component_ref (src
, sf
);
6557 dst
= build_simple_mem_ref_loc (loc
, arg
);
6558 dst
= omp_build_component_ref (dst
, f
);
6559 t
= build2 (MODIFY_EXPR
, TREE_TYPE (dst
), dst
, src
);
6560 append_to_statement_list (t
, &list
);
6562 case OMP_CLAUSE_FIRSTPRIVATE
:
6563 decl
= OMP_CLAUSE_DECL (c
);
6564 if (is_variable_sized (decl
))
6566 n
= splay_tree_lookup (ctx
->field_map
, (splay_tree_key
) decl
);
6569 f
= (tree
) n
->value
;
6570 if (tcctx
.cb
.decl_map
)
6571 f
= *(tree
*) pointer_map_contains (tcctx
.cb
.decl_map
, f
);
6572 n
= splay_tree_lookup (ctx
->sfield_map
, (splay_tree_key
) decl
);
6575 sf
= (tree
) n
->value
;
6576 if (tcctx
.cb
.decl_map
)
6577 sf
= *(tree
*) pointer_map_contains (tcctx
.cb
.decl_map
, sf
);
6578 src
= build_simple_mem_ref_loc (loc
, sarg
);
6579 src
= omp_build_component_ref (src
, sf
);
6580 if (use_pointer_for_field (decl
, NULL
) || is_reference (decl
))
6581 src
= build_simple_mem_ref_loc (loc
, src
);
6585 dst
= build_simple_mem_ref_loc (loc
, arg
);
6586 dst
= omp_build_component_ref (dst
, f
);
6587 t
= lang_hooks
.decls
.omp_clause_copy_ctor (c
, dst
, src
);
6588 append_to_statement_list (t
, &list
);
6590 case OMP_CLAUSE_PRIVATE
:
6591 if (! OMP_CLAUSE_PRIVATE_OUTER_REF (c
))
6593 decl
= OMP_CLAUSE_DECL (c
);
6594 n
= splay_tree_lookup (ctx
->field_map
, (splay_tree_key
) decl
);
6595 f
= (tree
) n
->value
;
6596 if (tcctx
.cb
.decl_map
)
6597 f
= *(tree
*) pointer_map_contains (tcctx
.cb
.decl_map
, f
);
6598 n
= splay_tree_lookup (ctx
->sfield_map
, (splay_tree_key
) decl
);
6601 sf
= (tree
) n
->value
;
6602 if (tcctx
.cb
.decl_map
)
6603 sf
= *(tree
*) pointer_map_contains (tcctx
.cb
.decl_map
, sf
);
6604 src
= build_simple_mem_ref_loc (loc
, sarg
);
6605 src
= omp_build_component_ref (src
, sf
);
6606 if (use_pointer_for_field (decl
, NULL
))
6607 src
= build_simple_mem_ref_loc (loc
, src
);
6611 dst
= build_simple_mem_ref_loc (loc
, arg
);
6612 dst
= omp_build_component_ref (dst
, f
);
6613 t
= build2 (MODIFY_EXPR
, TREE_TYPE (dst
), dst
, src
);
6614 append_to_statement_list (t
, &list
);
6620 /* Last pass: handle VLA firstprivates. */
6621 if (tcctx
.cb
.decl_map
)
6622 for (c
= gimple_omp_task_clauses (task_stmt
); c
; c
= OMP_CLAUSE_CHAIN (c
))
6623 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_FIRSTPRIVATE
)
6627 decl
= OMP_CLAUSE_DECL (c
);
6628 if (!is_variable_sized (decl
))
6630 n
= splay_tree_lookup (ctx
->field_map
, (splay_tree_key
) decl
);
6633 f
= (tree
) n
->value
;
6634 f
= *(tree
*) pointer_map_contains (tcctx
.cb
.decl_map
, f
);
6635 gcc_assert (DECL_HAS_VALUE_EXPR_P (decl
));
6636 ind
= DECL_VALUE_EXPR (decl
);
6637 gcc_assert (TREE_CODE (ind
) == INDIRECT_REF
);
6638 gcc_assert (DECL_P (TREE_OPERAND (ind
, 0)));
6639 n
= splay_tree_lookup (ctx
->sfield_map
,
6640 (splay_tree_key
) TREE_OPERAND (ind
, 0));
6641 sf
= (tree
) n
->value
;
6642 sf
= *(tree
*) pointer_map_contains (tcctx
.cb
.decl_map
, sf
);
6643 src
= build_simple_mem_ref_loc (loc
, sarg
);
6644 src
= omp_build_component_ref (src
, sf
);
6645 src
= build_simple_mem_ref_loc (loc
, src
);
6646 dst
= build_simple_mem_ref_loc (loc
, arg
);
6647 dst
= omp_build_component_ref (dst
, f
);
6648 t
= lang_hooks
.decls
.omp_clause_copy_ctor (c
, dst
, src
);
6649 append_to_statement_list (t
, &list
);
6650 n
= splay_tree_lookup (ctx
->field_map
,
6651 (splay_tree_key
) TREE_OPERAND (ind
, 0));
6652 df
= (tree
) n
->value
;
6653 df
= *(tree
*) pointer_map_contains (tcctx
.cb
.decl_map
, df
);
6654 ptr
= build_simple_mem_ref_loc (loc
, arg
);
6655 ptr
= omp_build_component_ref (ptr
, df
);
6656 t
= build2 (MODIFY_EXPR
, TREE_TYPE (ptr
), ptr
,
6657 build_fold_addr_expr_loc (loc
, dst
));
6658 append_to_statement_list (t
, &list
);
6661 t
= build1 (RETURN_EXPR
, void_type_node
, NULL
);
6662 append_to_statement_list (t
, &list
);
6664 if (tcctx
.cb
.decl_map
)
6665 pointer_map_destroy (tcctx
.cb
.decl_map
);
6666 pop_gimplify_context (NULL
);
6667 BIND_EXPR_BODY (bind
) = list
;
6669 current_function_decl
= ctx
->cb
.src_fn
;
6672 /* Lower the OpenMP parallel or task directive in the current statement
6673 in GSI_P. CTX holds context information for the directive. */
6676 lower_omp_taskreg (gimple_stmt_iterator
*gsi_p
, omp_context
*ctx
)
6680 gimple stmt
= gsi_stmt (*gsi_p
);
6681 gimple par_bind
, bind
;
6682 gimple_seq par_body
, olist
, ilist
, par_olist
, par_ilist
, new_body
;
6683 struct gimplify_ctx gctx
;
6684 location_t loc
= gimple_location (stmt
);
6686 clauses
= gimple_omp_taskreg_clauses (stmt
);
6687 par_bind
= gimple_seq_first_stmt (gimple_omp_body (stmt
));
6688 par_body
= gimple_bind_body (par_bind
);
6689 child_fn
= ctx
->cb
.dst_fn
;
6690 if (gimple_code (stmt
) == GIMPLE_OMP_PARALLEL
6691 && !gimple_omp_parallel_combined_p (stmt
))
6693 struct walk_stmt_info wi
;
6696 memset (&wi
, 0, sizeof (wi
));
6699 walk_gimple_seq (par_body
, check_combined_parallel
, NULL
, &wi
);
6701 gimple_omp_parallel_set_combined_p (stmt
, true);
6703 if (ctx
->srecord_type
)
6704 create_task_copyfn (stmt
, ctx
);
6706 push_gimplify_context (&gctx
);
6710 lower_rec_input_clauses (clauses
, &par_ilist
, &par_olist
, ctx
);
6711 lower_omp (&par_body
, ctx
);
6712 if (gimple_code (stmt
) == GIMPLE_OMP_PARALLEL
)
6713 lower_reduction_clauses (clauses
, &par_olist
, ctx
);
6715 /* Declare all the variables created by mapping and the variables
6716 declared in the scope of the parallel body. */
6717 record_vars_into (ctx
->block_vars
, child_fn
);
6718 record_vars_into (gimple_bind_vars (par_bind
), child_fn
);
6720 if (ctx
->record_type
)
6723 = create_tmp_var (ctx
->srecord_type
? ctx
->srecord_type
6724 : ctx
->record_type
, ".omp_data_o");
6725 DECL_NAMELESS (ctx
->sender_decl
) = 1;
6726 TREE_ADDRESSABLE (ctx
->sender_decl
) = 1;
6727 gimple_omp_taskreg_set_data_arg (stmt
, ctx
->sender_decl
);
6732 lower_send_clauses (clauses
, &ilist
, &olist
, ctx
);
6733 lower_send_shared_vars (&ilist
, &olist
, ctx
);
6735 /* Once all the expansions are done, sequence all the different
6736 fragments inside gimple_omp_body. */
6740 if (ctx
->record_type
)
6742 t
= build_fold_addr_expr_loc (loc
, ctx
->sender_decl
);
6743 /* fixup_child_record_type might have changed receiver_decl's type. */
6744 t
= fold_convert_loc (loc
, TREE_TYPE (ctx
->receiver_decl
), t
);
6745 gimple_seq_add_stmt (&new_body
,
6746 gimple_build_assign (ctx
->receiver_decl
, t
));
6749 gimple_seq_add_seq (&new_body
, par_ilist
);
6750 gimple_seq_add_seq (&new_body
, par_body
);
6751 gimple_seq_add_seq (&new_body
, par_olist
);
6752 new_body
= maybe_catch_exception (new_body
);
6753 gimple_seq_add_stmt (&new_body
, gimple_build_omp_return (false));
6754 gimple_omp_set_body (stmt
, new_body
);
6756 bind
= gimple_build_bind (NULL
, NULL
, gimple_bind_block (par_bind
));
6757 gsi_replace (gsi_p
, bind
, true);
6758 gimple_bind_add_seq (bind
, ilist
);
6759 gimple_bind_add_stmt (bind
, stmt
);
6760 gimple_bind_add_seq (bind
, olist
);
6762 pop_gimplify_context (NULL
);
6765 /* Callback for lower_omp_1. Return non-NULL if *tp needs to be
6766 regimplified. If DATA is non-NULL, lower_omp_1 is outside
6767 of OpenMP context, but with task_shared_vars set. */
6770 lower_omp_regimplify_p (tree
*tp
, int *walk_subtrees
,
6775 /* Any variable with DECL_VALUE_EXPR needs to be regimplified. */
6776 if (TREE_CODE (t
) == VAR_DECL
&& data
== NULL
&& DECL_HAS_VALUE_EXPR_P (t
))
6779 if (task_shared_vars
6781 && bitmap_bit_p (task_shared_vars
, DECL_UID (t
)))
6784 /* If a global variable has been privatized, TREE_CONSTANT on
6785 ADDR_EXPR might be wrong. */
6786 if (data
== NULL
&& TREE_CODE (t
) == ADDR_EXPR
)
6787 recompute_tree_invariant_for_addr_expr (t
);
6789 *walk_subtrees
= !TYPE_P (t
) && !DECL_P (t
);
6794 lower_omp_1 (gimple_stmt_iterator
*gsi_p
, omp_context
*ctx
)
6796 gimple stmt
= gsi_stmt (*gsi_p
);
6797 struct walk_stmt_info wi
;
6799 if (gimple_has_location (stmt
))
6800 input_location
= gimple_location (stmt
);
6802 if (task_shared_vars
)
6803 memset (&wi
, '\0', sizeof (wi
));
6805 /* If we have issued syntax errors, avoid doing any heavy lifting.
6806 Just replace the OpenMP directives with a NOP to avoid
6807 confusing RTL expansion. */
6808 if (seen_error () && is_gimple_omp (stmt
))
6810 gsi_replace (gsi_p
, gimple_build_nop (), true);
6814 switch (gimple_code (stmt
))
6817 if ((ctx
|| task_shared_vars
)
6818 && (walk_tree (gimple_cond_lhs_ptr (stmt
), lower_omp_regimplify_p
,
6819 ctx
? NULL
: &wi
, NULL
)
6820 || walk_tree (gimple_cond_rhs_ptr (stmt
), lower_omp_regimplify_p
,
6821 ctx
? NULL
: &wi
, NULL
)))
6822 gimple_regimplify_operands (stmt
, gsi_p
);
6825 lower_omp (gimple_catch_handler_ptr (stmt
), ctx
);
6827 case GIMPLE_EH_FILTER
:
6828 lower_omp (gimple_eh_filter_failure_ptr (stmt
), ctx
);
6831 lower_omp (gimple_try_eval_ptr (stmt
), ctx
);
6832 lower_omp (gimple_try_cleanup_ptr (stmt
), ctx
);
6835 lower_omp (gimple_bind_body_ptr (stmt
), ctx
);
6837 case GIMPLE_OMP_PARALLEL
:
6838 case GIMPLE_OMP_TASK
:
6839 ctx
= maybe_lookup_ctx (stmt
);
6840 lower_omp_taskreg (gsi_p
, ctx
);
6842 case GIMPLE_OMP_FOR
:
6843 ctx
= maybe_lookup_ctx (stmt
);
6845 lower_omp_for (gsi_p
, ctx
);
6847 case GIMPLE_OMP_SECTIONS
:
6848 ctx
= maybe_lookup_ctx (stmt
);
6850 lower_omp_sections (gsi_p
, ctx
);
6852 case GIMPLE_OMP_SINGLE
:
6853 ctx
= maybe_lookup_ctx (stmt
);
6855 lower_omp_single (gsi_p
, ctx
);
6857 case GIMPLE_OMP_MASTER
:
6858 ctx
= maybe_lookup_ctx (stmt
);
6860 lower_omp_master (gsi_p
, ctx
);
6862 case GIMPLE_OMP_ORDERED
:
6863 ctx
= maybe_lookup_ctx (stmt
);
6865 lower_omp_ordered (gsi_p
, ctx
);
6867 case GIMPLE_OMP_CRITICAL
:
6868 ctx
= maybe_lookup_ctx (stmt
);
6870 lower_omp_critical (gsi_p
, ctx
);
6872 case GIMPLE_OMP_ATOMIC_LOAD
:
6873 if ((ctx
|| task_shared_vars
)
6874 && walk_tree (gimple_omp_atomic_load_rhs_ptr (stmt
),
6875 lower_omp_regimplify_p
, ctx
? NULL
: &wi
, NULL
))
6876 gimple_regimplify_operands (stmt
, gsi_p
);
6879 if ((ctx
|| task_shared_vars
)
6880 && walk_gimple_op (stmt
, lower_omp_regimplify_p
,
6882 gimple_regimplify_operands (stmt
, gsi_p
);
6888 lower_omp (gimple_seq
*body
, omp_context
*ctx
)
6890 location_t saved_location
= input_location
;
6891 gimple_stmt_iterator gsi
;
6892 for (gsi
= gsi_start (*body
); !gsi_end_p (gsi
); gsi_next (&gsi
))
6893 lower_omp_1 (&gsi
, ctx
);
6894 input_location
= saved_location
;
6897 /* Main entry point. */
6900 execute_lower_omp (void)
6904 /* This pass always runs, to provide PROP_gimple_lomp.
6905 But there is nothing to do unless -fopenmp is given. */
6906 if (flag_openmp
== 0)
6909 all_contexts
= splay_tree_new (splay_tree_compare_pointers
, 0,
6910 delete_omp_context
);
6912 body
= gimple_body (current_function_decl
);
6913 scan_omp (&body
, NULL
);
6914 gcc_assert (taskreg_nesting_level
== 0);
6916 if (all_contexts
->root
)
6918 struct gimplify_ctx gctx
;
6920 if (task_shared_vars
)
6921 push_gimplify_context (&gctx
);
6922 lower_omp (&body
, NULL
);
6923 if (task_shared_vars
)
6924 pop_gimplify_context (NULL
);
6929 splay_tree_delete (all_contexts
);
6930 all_contexts
= NULL
;
6932 BITMAP_FREE (task_shared_vars
);
6936 struct gimple_opt_pass pass_lower_omp
=
6940 "omplower", /* name */
6942 execute_lower_omp
, /* execute */
6945 0, /* static_pass_number */
6946 TV_NONE
, /* tv_id */
6947 PROP_gimple_any
, /* properties_required */
6948 PROP_gimple_lomp
, /* properties_provided */
6949 0, /* properties_destroyed */
6950 0, /* todo_flags_start */
6951 0 /* todo_flags_finish */
6955 /* The following is a utility to diagnose OpenMP structured block violations.
6956 It is not part of the "omplower" pass, as that's invoked too late. It
6957 should be invoked by the respective front ends after gimplification. */
6959 static splay_tree all_labels
;
6961 /* Check for mismatched contexts and generate an error if needed. Return
6962 true if an error is detected. */
6965 diagnose_sb_0 (gimple_stmt_iterator
*gsi_p
,
6966 gimple branch_ctx
, gimple label_ctx
)
6968 if (label_ctx
== branch_ctx
)
6973 Previously we kept track of the label's entire context in diagnose_sb_[12]
6974 so we could traverse it and issue a correct "exit" or "enter" error
6975 message upon a structured block violation.
6977 We built the context by building a list with tree_cons'ing, but there is
6978 no easy counterpart in gimple tuples. It seems like far too much work
6979 for issuing exit/enter error messages. If someone really misses the
6980 distinct error message... patches welcome.
6984 /* Try to avoid confusing the user by producing and error message
6985 with correct "exit" or "enter" verbiage. We prefer "exit"
6986 unless we can show that LABEL_CTX is nested within BRANCH_CTX. */
6987 if (branch_ctx
== NULL
)
6993 if (TREE_VALUE (label_ctx
) == branch_ctx
)
6998 label_ctx
= TREE_CHAIN (label_ctx
);
7003 error ("invalid exit from OpenMP structured block");
7005 error ("invalid entry to OpenMP structured block");
7008 /* If it's obvious we have an invalid entry, be specific about the error. */
7009 if (branch_ctx
== NULL
)
7010 error ("invalid entry to OpenMP structured block");
7012 /* Otherwise, be vague and lazy, but efficient. */
7013 error ("invalid branch to/from an OpenMP structured block");
7015 gsi_replace (gsi_p
, gimple_build_nop (), false);
7019 /* Pass 1: Create a minimal tree of OpenMP structured blocks, and record
7020 where each label is found. */
7023 diagnose_sb_1 (gimple_stmt_iterator
*gsi_p
, bool *handled_ops_p
,
7024 struct walk_stmt_info
*wi
)
7026 gimple context
= (gimple
) wi
->info
;
7027 gimple inner_context
;
7028 gimple stmt
= gsi_stmt (*gsi_p
);
7030 *handled_ops_p
= true;
7032 switch (gimple_code (stmt
))
7036 case GIMPLE_OMP_PARALLEL
:
7037 case GIMPLE_OMP_TASK
:
7038 case GIMPLE_OMP_SECTIONS
:
7039 case GIMPLE_OMP_SINGLE
:
7040 case GIMPLE_OMP_SECTION
:
7041 case GIMPLE_OMP_MASTER
:
7042 case GIMPLE_OMP_ORDERED
:
7043 case GIMPLE_OMP_CRITICAL
:
7044 /* The minimal context here is just the current OMP construct. */
7045 inner_context
= stmt
;
7046 wi
->info
= inner_context
;
7047 walk_gimple_seq (gimple_omp_body (stmt
), diagnose_sb_1
, NULL
, wi
);
7051 case GIMPLE_OMP_FOR
:
7052 inner_context
= stmt
;
7053 wi
->info
= inner_context
;
7054 /* gimple_omp_for_{index,initial,final} are all DECLs; no need to
7056 walk_gimple_seq (gimple_omp_for_pre_body (stmt
),
7057 diagnose_sb_1
, NULL
, wi
);
7058 walk_gimple_seq (gimple_omp_body (stmt
), diagnose_sb_1
, NULL
, wi
);
7063 splay_tree_insert (all_labels
, (splay_tree_key
) gimple_label_label (stmt
),
7064 (splay_tree_value
) context
);
7074 /* Pass 2: Check each branch and see if its context differs from that of
7075 the destination label's context. */
7078 diagnose_sb_2 (gimple_stmt_iterator
*gsi_p
, bool *handled_ops_p
,
7079 struct walk_stmt_info
*wi
)
7081 gimple context
= (gimple
) wi
->info
;
7083 gimple stmt
= gsi_stmt (*gsi_p
);
7085 *handled_ops_p
= true;
7087 switch (gimple_code (stmt
))
7091 case GIMPLE_OMP_PARALLEL
:
7092 case GIMPLE_OMP_TASK
:
7093 case GIMPLE_OMP_SECTIONS
:
7094 case GIMPLE_OMP_SINGLE
:
7095 case GIMPLE_OMP_SECTION
:
7096 case GIMPLE_OMP_MASTER
:
7097 case GIMPLE_OMP_ORDERED
:
7098 case GIMPLE_OMP_CRITICAL
:
7100 walk_gimple_seq_mod (gimple_omp_body_ptr (stmt
), diagnose_sb_2
, NULL
, wi
);
7104 case GIMPLE_OMP_FOR
:
7106 /* gimple_omp_for_{index,initial,final} are all DECLs; no need to
7108 walk_gimple_seq_mod (gimple_omp_for_pre_body_ptr (stmt
),
7109 diagnose_sb_2
, NULL
, wi
);
7110 walk_gimple_seq_mod (gimple_omp_body_ptr (stmt
), diagnose_sb_2
, NULL
, wi
);
7116 tree lab
= gimple_cond_true_label (stmt
);
7119 n
= splay_tree_lookup (all_labels
,
7120 (splay_tree_key
) lab
);
7121 diagnose_sb_0 (gsi_p
, context
,
7122 n
? (gimple
) n
->value
: NULL
);
7124 lab
= gimple_cond_false_label (stmt
);
7127 n
= splay_tree_lookup (all_labels
,
7128 (splay_tree_key
) lab
);
7129 diagnose_sb_0 (gsi_p
, context
,
7130 n
? (gimple
) n
->value
: NULL
);
7137 tree lab
= gimple_goto_dest (stmt
);
7138 if (TREE_CODE (lab
) != LABEL_DECL
)
7141 n
= splay_tree_lookup (all_labels
, (splay_tree_key
) lab
);
7142 diagnose_sb_0 (gsi_p
, context
, n
? (gimple
) n
->value
: NULL
);
7149 for (i
= 0; i
< gimple_switch_num_labels (stmt
); ++i
)
7151 tree lab
= CASE_LABEL (gimple_switch_label (stmt
, i
));
7152 n
= splay_tree_lookup (all_labels
, (splay_tree_key
) lab
);
7153 if (n
&& diagnose_sb_0 (gsi_p
, context
, (gimple
) n
->value
))
7160 diagnose_sb_0 (gsi_p
, context
, NULL
);
7171 diagnose_omp_structured_block_errors (void)
7173 struct walk_stmt_info wi
;
7174 gimple_seq body
= gimple_body (current_function_decl
);
7176 all_labels
= splay_tree_new (splay_tree_compare_pointers
, 0, 0);
7178 memset (&wi
, 0, sizeof (wi
));
7179 walk_gimple_seq (body
, diagnose_sb_1
, NULL
, &wi
);
7181 memset (&wi
, 0, sizeof (wi
));
7182 wi
.want_locations
= true;
7183 walk_gimple_seq_mod (&body
, diagnose_sb_2
, NULL
, &wi
);
7185 gimple_set_body (current_function_decl
, body
);
7187 splay_tree_delete (all_labels
);
7194 gate_diagnose_omp_blocks (void)
7196 return flag_openmp
!= 0;
7199 struct gimple_opt_pass pass_diagnose_omp_blocks
=
7203 "*diagnose_omp_blocks", /* name */
7204 gate_diagnose_omp_blocks
, /* gate */
7205 diagnose_omp_structured_block_errors
, /* execute */
7208 0, /* static_pass_number */
7209 TV_NONE
, /* tv_id */
7210 PROP_gimple_any
, /* properties_required */
7211 0, /* properties_provided */
7212 0, /* properties_destroyed */
7213 0, /* todo_flags_start */
7214 0, /* todo_flags_finish */
7218 #include "gt-omp-low.h"