From 1160ec9a141faf1c4c0496c7412c8febeb623962 Mon Sep 17 00:00:00 2001 From: Jakub Jelinek Date: Tue, 16 Jun 2020 16:31:13 +0200 Subject: openmp: Initial part of OpenMP 5.0 non-rectangular loop support OpenMP 5.0 adds support for non-rectangular loop collapses, e.g. triangular and more complex. This patch deals just with the diagnostics so that they aren't rejected immediately as before. As the spec generally requires as before that the iteration variable initializer and bound in the comparison as invariant vs. the outermost loop, and just add some exceptional forms that can violate that, we need to avoid folding the expressions until we can detect them and in order to avoid folding it later on, I chose to use a TREE_VEC in those expressions to hold the var_outer * expr1 + expr2 triplet, the patch adds pretty-printing of that, gimplification etc. and just sorry_at during omp expansion for now. The next step will be to implement the different cases of that one by one. 2020-06-16 Jakub Jelinek gcc/ * tree.h (OMP_FOR_NON_RECTANGULAR): Define. * gimplify.c (gimplify_omp_for): Diagnose schedule, ordered or dist_schedule clause on non-rectangular loops. Handle gimplification of non-rectangular lb/b expressions. When changing iteration variable, adjust also non-rectangular lb/b expressions referencing that. * omp-general.h (struct omp_for_data_loop): Add m1, m2 and outer members. (struct omp_for_data): Add non_rect member. * omp-general.c (omp_extract_for_data): Handle non-rectangular loops. Fill in non_rect, m1, m2 and outer. * omp-low.c (lower_omp_for): Handle non-rectangular lb/b expressions. * omp-expand.c (expand_omp_for): Emit sorry_at for unsupported non-rectangular loop cases and assert for cases that can't be non-rectangular. * tree-pretty-print.c (dump_mem_ref): Formatting fix. (dump_omp_loop_non_rect_expr): New function. (dump_generic_node): Handle non-rectangular OpenMP loops. * tree-pretty-print.h (dump_omp_loop_non_rect_expr): Declare. * gimple-pretty-print.c (dump_gimple_omp_for): Handle non-rectangular OpenMP loops. gcc/c-family/ * c-common.h (c_omp_check_loop_iv_exprs): Add an int argument. * c-omp.c (struct c_omp_check_loop_iv_data): Add maybe_nonrect and idx members. (c_omp_is_loop_iterator): New function. (c_omp_check_loop_iv_r): Use it. Add support for silent scanning if outer loop iterator is present. Perform duplicate checking through hash_set in the function rather than expecting caller to do that. Pass NULL instead of d->ppset to walk_tree_1. (c_omp_check_nonrect_loop_iv): New function. (c_omp_check_loop_iv): Use it. Fill in new members, allow non-rectangular loop forms, diagnose multiple associated loops with the same iterator. Pass NULL instead of &pset to walk_tree_1. (c_omp_check_loop_iv_exprs): Likewise. gcc/c/ * c-parser.c (c_parser_expr_no_commas): Save, clear and restore c_in_omp_for. (c_parser_omp_for_loop): Set c_in_omp_for around some calls to avoid premature c_fully_fold. Defer explicit c_fully_fold calls to after c_finish_omp_for. * c-tree.h (c_in_omp_for): Declare. * c-typeck.c (c_in_omp_for): Define. (build_modify_expr): Avoid c_fully_fold if c_in_omp_for. (digest_init): Likewise. (build_binary_op): Likewise. gcc/cp/ * semantics.c (handle_omp_for_class_iterator): Adjust c_omp_check_loop_iv_exprs caller. (finish_omp_for): Likewise. Don't call fold_build_cleanup_point_expr before calling c_finish_omp_for and c_omp_check_loop_iv, move it after those calls. * pt.c (tsubst_omp_for_iterator): Handle non-rectangular loops. gcc/testsuite/ * c-c++-common/gomp/loop-6.c: New test. * gcc.dg/gomp/loop-1.c: Don't expect diagnostics on valid non-rectangular loops. * gcc.dg/gomp/loop-2.c: New test. * g++.dg/gomp/loop-1.C: Don't expect diagnostics on valid non-rectangular loops. * g++.dg/gomp/loop-2.C: Likewise. * g++.dg/gomp/loop-5.C: New test. * g++.dg/gomp/loop-6.C: New test. --- gcc/cp/pt.c | 27 ++++++++++++++++++-- gcc/cp/semantics.c | 74 +++++++++++++++++++++++++++++++----------------------- 2 files changed, 68 insertions(+), 33 deletions(-) (limited to 'gcc/cp') diff --git a/gcc/cp/pt.c b/gcc/cp/pt.c index efc69d5..07b9956 100644 --- a/gcc/cp/pt.c +++ b/gcc/cp/pt.c @@ -17449,7 +17449,16 @@ tsubst_omp_for_iterator (tree t, int i, tree declv, tree &orig_declv, else decl = RECUR (decl); } - init = RECUR (init); + if (init && TREE_CODE (init) == TREE_VEC) + { + init = copy_node (init); + TREE_VEC_ELT (init, 0) + = tsubst_decl (TREE_VEC_ELT (init, 0), args, complain); + TREE_VEC_ELT (init, 1) = RECUR (TREE_VEC_ELT (init, 1)); + TREE_VEC_ELT (init, 2) = RECUR (TREE_VEC_ELT (init, 2)); + } + else + init = RECUR (init); if (orig_declv && OMP_FOR_ORIG_DECLS (t)) { @@ -17501,7 +17510,21 @@ tsubst_omp_for_iterator (tree t, int i, tree declv, tree &orig_declv, if (!range_for) { - cond = RECUR (TREE_VEC_ELT (OMP_FOR_COND (t), i)); + cond = TREE_VEC_ELT (OMP_FOR_COND (t), i); + if (COMPARISON_CLASS_P (cond) + && TREE_CODE (TREE_OPERAND (cond, 1)) == TREE_VEC) + { + tree lhs = RECUR (TREE_OPERAND (cond, 0)); + tree rhs = copy_node (TREE_OPERAND (cond, 1)); + TREE_VEC_ELT (rhs, 0) + = tsubst_decl (TREE_VEC_ELT (rhs, 0), args, complain); + TREE_VEC_ELT (rhs, 1) = RECUR (TREE_VEC_ELT (rhs, 1)); + TREE_VEC_ELT (rhs, 2) = RECUR (TREE_VEC_ELT (rhs, 2)); + cond = build2 (TREE_CODE (cond), TREE_TYPE (cond), + lhs, rhs); + } + else + cond = RECUR (cond); incr = TREE_VEC_ELT (OMP_FOR_INCR (t), i); if (TREE_CODE (incr) == MODIFY_EXPR) { diff --git a/gcc/cp/semantics.c b/gcc/cp/semantics.c index 2e65c27..d63cea9 100644 --- a/gcc/cp/semantics.c +++ b/gcc/cp/semantics.c @@ -8594,7 +8594,7 @@ handle_omp_for_class_iterator (int i, location_t locus, enum tree_code code, TREE_OPERAND (cond, 1), iter); return true; } - if (!c_omp_check_loop_iv_exprs (locus, orig_declv, + if (!c_omp_check_loop_iv_exprs (locus, orig_declv, i, TREE_VEC_ELT (declv, i), NULL_TREE, cond, cp_walk_subtrees)) return true; @@ -8980,8 +8980,8 @@ finish_omp_for (location_t locus, enum tree_code code, tree declv, tree orig_init; FOR_EACH_VEC_ELT (*orig_inits, i, orig_init) if (orig_init - && !c_omp_check_loop_iv_exprs (locus, orig_declv - ? orig_declv : declv, + && !c_omp_check_loop_iv_exprs (locus, + orig_declv ? orig_declv : declv, i, TREE_VEC_ELT (declv, i), orig_init, NULL_TREE, cp_walk_subtrees)) fail = true; @@ -9075,35 +9075,11 @@ finish_omp_for (location_t locus, enum tree_code code, tree declv, return NULL; } - if (!processing_template_decl) - { - init = fold_build_cleanup_point_expr (TREE_TYPE (init), init); - init = cp_build_modify_expr (elocus, decl, NOP_EXPR, init, - tf_warning_or_error); - } + if (!processing_template_decl && TREE_CODE (init) != TREE_VEC) + init = cp_build_modify_expr (elocus, decl, NOP_EXPR, init, + tf_warning_or_error); else init = build2 (MODIFY_EXPR, void_type_node, decl, init); - if (cond - && TREE_SIDE_EFFECTS (cond) - && COMPARISON_CLASS_P (cond) - && !processing_template_decl) - { - tree t = TREE_OPERAND (cond, 0); - if (TREE_SIDE_EFFECTS (t) - && t != decl - && (TREE_CODE (t) != NOP_EXPR - || TREE_OPERAND (t, 0) != decl)) - TREE_OPERAND (cond, 0) - = fold_build_cleanup_point_expr (TREE_TYPE (t), t); - - t = TREE_OPERAND (cond, 1); - if (TREE_SIDE_EFFECTS (t) - && t != decl - && (TREE_CODE (t) != NOP_EXPR - || TREE_OPERAND (t, 0) != decl)) - TREE_OPERAND (cond, 1) - = fold_build_cleanup_point_expr (TREE_TYPE (t), t); - } if (decl == error_mark_node || init == error_mark_node) return NULL; @@ -9132,9 +9108,45 @@ finish_omp_for (location_t locus, enum tree_code code, tree declv, for (i = 0; i < TREE_VEC_LENGTH (OMP_FOR_INCR (omp_for)); i++) { - decl = TREE_OPERAND (TREE_VEC_ELT (OMP_FOR_INIT (omp_for), i), 0); + init = TREE_VEC_ELT (OMP_FOR_INIT (omp_for), i); + decl = TREE_OPERAND (init, 0); + cond = TREE_VEC_ELT (OMP_FOR_COND (omp_for), i); incr = TREE_VEC_ELT (OMP_FOR_INCR (omp_for), i); + if (!processing_template_decl) + { + if (TREE_CODE (TREE_OPERAND (init, 1)) == TREE_VEC) + { + tree t = TREE_VEC_ELT (TREE_OPERAND (init, 1), 1); + TREE_VEC_ELT (TREE_OPERAND (init, 1), 1) + = fold_build_cleanup_point_expr (TREE_TYPE (t), t); + t = TREE_VEC_ELT (TREE_OPERAND (init, 1), 2); + TREE_VEC_ELT (TREE_OPERAND (init, 1), 2) + = fold_build_cleanup_point_expr (TREE_TYPE (t), t); + } + else + { + tree t = TREE_OPERAND (init, 1); + TREE_OPERAND (init, 1) + = fold_build_cleanup_point_expr (TREE_TYPE (t), t); + } + if (TREE_CODE (TREE_OPERAND (cond, 1)) == TREE_VEC) + { + tree t = TREE_VEC_ELT (TREE_OPERAND (cond, 1), 1); + TREE_VEC_ELT (TREE_OPERAND (cond, 1), 1) + = fold_build_cleanup_point_expr (TREE_TYPE (t), t); + t = TREE_VEC_ELT (TREE_OPERAND (cond, 1), 2); + TREE_VEC_ELT (TREE_OPERAND (cond, 1), 2) + = fold_build_cleanup_point_expr (TREE_TYPE (t), t); + } + else + { + tree t = TREE_OPERAND (cond, 1); + TREE_OPERAND (cond, 1) + = fold_build_cleanup_point_expr (TREE_TYPE (t), t); + } + } + if (TREE_CODE (incr) != MODIFY_EXPR) continue; -- cgit v1.1