From patchwork Wed Oct 29 18:47:52 2014 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: David Malcolm X-Patchwork-Id: 404766 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Received: from sourceware.org (server1.sourceware.org [209.132.180.131]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by ozlabs.org (Postfix) with ESMTPS id A7C8F14003E for ; Thu, 30 Oct 2014 05:53:41 +1100 (AEDT) DomainKey-Signature: a=rsa-sha1; c=nofws; d=gcc.gnu.org; h=list-id :list-unsubscribe:list-archive:list-post:list-help:sender:from :to:cc:subject:date:message-id:in-reply-to:references; q=dns; s= default; b=LQvuc+Nx2hTXBmCtlgUBI16eQnmWAU6ybxmVn7EPgDU3vhswbGdVH s5jZ+4p4j+z3vwuNApF/CY0RE+PFvYYRaBT39GT1qEdBj0jWH8+RiBqrwtWRdWav pyOM9QsCSnPf/1c0DYvSpYWCLD/D0MWYay2ZyFtjjASKBgZNeAyLy0= DKIM-Signature: v=1; a=rsa-sha1; c=relaxed; d=gcc.gnu.org; h=list-id :list-unsubscribe:list-archive:list-post:list-help:sender:from :to:cc:subject:date:message-id:in-reply-to:references; s= default; bh=FUwxmXJQIEVl74iplK4Yzz7r0tw=; b=QvIYzMEfwUakTDT0R77M VMwmiqJSzLprVmv+7PNgtnAg6RhzojUK3L44sIvFyGOAZ6mMhNweEdp2Tvn3WbSA wBIanL8xWigCulECMFaGuzdXNwauiDOf1WNx0hdjTJ6eanZWt7KYPwllO741tRc1 PISJYmN4fZ15dpwYBv5kJ1k= Received: (qmail 28771 invoked by alias); 29 Oct 2014 18:52:26 -0000 Mailing-List: contact gcc-patches-help@gcc.gnu.org; run by ezmlm Precedence: bulk List-Id: List-Unsubscribe: List-Archive: List-Post: List-Help: Sender: gcc-patches-owner@gcc.gnu.org Delivered-To: mailing list gcc-patches@gcc.gnu.org Received: (qmail 28707 invoked by uid 89); 29 Oct 2014 18:52:25 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=-2.3 required=5.0 tests=AWL, BAYES_00, RP_MATCHES_RCVD, SPF_HELO_PASS autolearn=ham version=3.3.2 X-HELO: mx1.redhat.com Received: from mx1.redhat.com (HELO mx1.redhat.com) (209.132.183.28) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with (AES256-GCM-SHA384 encrypted) ESMTPS; Wed, 29 Oct 2014 18:52:17 +0000 Received: from int-mx13.intmail.prod.int.phx2.redhat.com (int-mx13.intmail.prod.int.phx2.redhat.com [10.5.11.26]) by mx1.redhat.com (8.14.4/8.14.4) with ESMTP id s9TIqFMd022237 (version=TLSv1/SSLv3 cipher=DHE-RSA-AES256-GCM-SHA384 bits=256 verify=FAIL) for ; Wed, 29 Oct 2014 14:52:16 -0400 Received: from surprise.redhat.com (vpn-235-224.phx2.redhat.com [10.3.235.224]) by int-mx13.intmail.prod.int.phx2.redhat.com (8.14.4/8.14.4) with ESMTP id s9TIqDvo028359; Wed, 29 Oct 2014 14:52:15 -0400 From: David Malcolm To: gcc-patches@gcc.gnu.org Cc: David Malcolm Subject: [gimple-classes, committed 02/10] Make all gimple_omp_for_ accessors typesafe Date: Wed, 29 Oct 2014 14:47:52 -0400 Message-Id: <1414608480-32461-3-git-send-email-dmalcolm@redhat.com> In-Reply-To: <1414608480-32461-1-git-send-email-dmalcolm@redhat.com> References: <1414608480-32461-1-git-send-email-dmalcolm@redhat.com> X-IsSubscribed: yes gcc/ChangeLog.gimple-classes: * gimple.h (gimple_omp_for_kind): Strengthen param from const_gimple to const gomp_for *. (gimple_omp_for_combined_p): Likewise. (gimple_omp_for_combined_into_p): Likewise. (gimple_omp_for_clauses): Likewise. (gimple_omp_for_index): Likewise. (gimple_omp_for_initial): Likewise. (gimple_omp_for_final): Likewise. (gimple_omp_for_incr): Likewise. (gimple_omp_for_pre_body): Likewise. (gimple_omp_for_cond): Likewise. (gimple_omp_for_clauses_ptr): Strengthen param from gimple to gomp_for *. (gimple_omp_for_set_clauses): Likewise. (gimple_omp_for_index_ptr): Likewise. (gimple_omp_for_set_index): Likewise. (gimple_omp_for_initial_ptr): Likewise. (gimple_omp_for_set_initial): Likewise. (gimple_omp_for_final_ptr): Likewise. (gimple_omp_for_set_final): Likewise. (gimple_omp_for_incr_ptr): Likewise. (gimple_omp_for_set_incr): Likewise. (gimple_omp_for_pre_body_ptr): Likewise. (gimple_omp_for_set_pre_body): Likewise. (gimple_omp_for_set_cond): Likewise. (gimple_omp_for_collapse): Strengthen param from gimple to const gomp_for *. * gimple-walk.c (walk_gimple_op): Within case GIMPLE_OMP_FOR, introduce local "omp_for_stmt" via a checked cast and use it in place of "stmt" for typesafety. (walk_gimple_stmt): Add checked cast. * gimple.c (gimple_copy): Within case GIMPLE_OMP_FOR, introduce locals "omp_for_stmt" and "omp_for_copy" via checked casts and use them in place of "stmt" and "copy" for typesafety. * omp-low.c (determine_parallel_type): Add a checked cast. (build_outer_var_ref): Likewise. (find_combined_for): Within case GIMPLE_OMP_FOR, introduce local "omp_for_stmt" via a checked cast and use it in place of "stmt" for typesafety. (check_omp_nesting_restrictions): Add checked casts. (check_omp_nesting_restrictions): Likewise. Within case GIMPLE_OMP_FOR, introduce local "omp_for_stmt" via a checked cast and use it in place of "stmt" for typesafety. (scan_omp_1_stmt): Add checked cast. (lower_rec_simd_input_clauses): Likewise. (lower_rec_input_clauses): Likewise. Introduce two locals named "omp_for_ctx_stmt" via checked casts and use them in place of "ctx->stmt" for typesafety. (lower_lastprivate_clauses): Add checked cast. (lower_reduction_clauses): Likewise. (expand_omp_for_init_vars): Likewise. (expand_omp_for_generic): Introduce local "omp_for_inner_stmt" via a checked cast and use in place of "inner_stmt" for typesafety. (expand_omp_for_static_nochunk): Add checked cast. (expand_omp_for_static_chunk): Likewise. (expand_omp_for): Introduce local "omp_for_stmt" via a checked cast and use in place of "last_stmt (region->entry)" for typesafety. (expand_omp): Add a checked cast. (diagnose_sb_0): Add checked casts. (diagnose_sb_1): Within case GIMPLE_OMP_FOR, introduce local "omp_for_stmt" via a checked cast and use it in place of "stmt" for typesafety. (diagnose_sb_2): Likewise. * tree-inline.c (remap_gimple_stmt): Likewise, introducing locals "omp_for_stmt" and "omp_for_copy", using in place of "stmt" and "copy". (estimate_num_insns): Likewise, introducing local "omp_for_stmt" for use in place of "stmt". * tree-nested.c (convert_nonlocal_reference_stmt): Likewise. (convert_local_reference_stmt): Likewise. (convert_gimple_call): Add a checked cast. --- gcc/ChangeLog.gimple-classes | 76 ++++++++++++++++++++ gcc/gimple-walk.c | 54 +++++++------- gcc/gimple.c | 39 +++++----- gcc/gimple.h | 136 ++++++++++++----------------------- gcc/omp-low.c | 167 ++++++++++++++++++++++++++----------------- gcc/tree-inline.c | 52 +++++++++----- gcc/tree-nested.c | 42 ++++++----- 7 files changed, 330 insertions(+), 236 deletions(-) diff --git a/gcc/ChangeLog.gimple-classes b/gcc/ChangeLog.gimple-classes index 07ebee7..68add33 100644 --- a/gcc/ChangeLog.gimple-classes +++ b/gcc/ChangeLog.gimple-classes @@ -1,5 +1,81 @@ 2014-10-29 David Malcolm + * gimple.h (gimple_omp_for_kind): Strengthen param from + const_gimple to const gomp_for *. + (gimple_omp_for_combined_p): Likewise. + (gimple_omp_for_combined_into_p): Likewise. + (gimple_omp_for_clauses): Likewise. + (gimple_omp_for_index): Likewise. + (gimple_omp_for_initial): Likewise. + (gimple_omp_for_final): Likewise. + (gimple_omp_for_incr): Likewise. + (gimple_omp_for_pre_body): Likewise. + (gimple_omp_for_cond): Likewise. + (gimple_omp_for_clauses_ptr): Strengthen param from gimple to + gomp_for *. + (gimple_omp_for_set_clauses): Likewise. + (gimple_omp_for_index_ptr): Likewise. + (gimple_omp_for_set_index): Likewise. + (gimple_omp_for_initial_ptr): Likewise. + (gimple_omp_for_set_initial): Likewise. + (gimple_omp_for_final_ptr): Likewise. + (gimple_omp_for_set_final): Likewise. + (gimple_omp_for_incr_ptr): Likewise. + (gimple_omp_for_set_incr): Likewise. + (gimple_omp_for_pre_body_ptr): Likewise. + (gimple_omp_for_set_pre_body): Likewise. + (gimple_omp_for_set_cond): Likewise. + (gimple_omp_for_collapse): Strengthen param from gimple to + const gomp_for *. + + * gimple-walk.c (walk_gimple_op): Within case GIMPLE_OMP_FOR, + introduce local "omp_for_stmt" via a checked cast and use it in + place of "stmt" for typesafety. + (walk_gimple_stmt): Add checked cast. + * gimple.c (gimple_copy): Within case GIMPLE_OMP_FOR, introduce + locals "omp_for_stmt" and "omp_for_copy" via checked casts and use + them in place of "stmt" and "copy" for typesafety. + * omp-low.c (determine_parallel_type): Add a checked cast. + (build_outer_var_ref): Likewise. + (find_combined_for): Within case GIMPLE_OMP_FOR, + introduce local "omp_for_stmt" via a checked cast and use it in + place of "stmt" for typesafety. + (check_omp_nesting_restrictions): Add checked casts. + (check_omp_nesting_restrictions): Likewise. Within + case GIMPLE_OMP_FOR, introduce local "omp_for_stmt" via a checked + cast and use it in place of "stmt" for typesafety. + (scan_omp_1_stmt): Add checked cast. + (lower_rec_simd_input_clauses): Likewise. + (lower_rec_input_clauses): Likewise. Introduce two locals named + "omp_for_ctx_stmt" via checked casts and use them in place of + "ctx->stmt" for typesafety. + (lower_lastprivate_clauses): Add checked cast. + (lower_reduction_clauses): Likewise. + (expand_omp_for_init_vars): Likewise. + (expand_omp_for_generic): Introduce local "omp_for_inner_stmt" via + a checked cast and use in place of "inner_stmt" for typesafety. + (expand_omp_for_static_nochunk): Add checked cast. + (expand_omp_for_static_chunk): Likewise. + (expand_omp_for): Introduce local "omp_for_stmt" via a checked + cast and use in place of "last_stmt (region->entry)" for + typesafety. + (expand_omp): Add a checked cast. + (diagnose_sb_0): Add checked casts. + (diagnose_sb_1): Within case GIMPLE_OMP_FOR, introduce local + "omp_for_stmt" via a checked cast and use it in place of "stmt" for + typesafety. + (diagnose_sb_2): Likewise. + * tree-inline.c (remap_gimple_stmt): Likewise, introducing locals + "omp_for_stmt" and "omp_for_copy", using in place of "stmt" and + "copy". + (estimate_num_insns): Likewise, introducing local "omp_for_stmt" + for use in place of "stmt". + * tree-nested.c (convert_nonlocal_reference_stmt): Likewise. + (convert_local_reference_stmt): Likewise. + (convert_gimple_call): Add a checked cast. + +2014-10-29 David Malcolm + * gimple.h (gimple_omp_task_clauses): Strengthen param from const_gimple to const gomp_task *. (gimple_omp_task_child_fn): Likewise. diff --git a/gcc/gimple-walk.c b/gcc/gimple-walk.c index 020e55f..28648c4 100644 --- a/gcc/gimple-walk.c +++ b/gcc/gimple-walk.c @@ -329,29 +329,32 @@ walk_gimple_op (gimple stmt, walk_tree_fn callback_op, break; case GIMPLE_OMP_FOR: - ret = walk_tree (gimple_omp_for_clauses_ptr (stmt), callback_op, wi, - pset); - if (ret) - return ret; - for (i = 0; i < gimple_omp_for_collapse (stmt); i++) - { - ret = walk_tree (gimple_omp_for_index_ptr (stmt, i), callback_op, - wi, pset); - if (ret) - return ret; - ret = walk_tree (gimple_omp_for_initial_ptr (stmt, i), callback_op, - wi, pset); - if (ret) - return ret; - ret = walk_tree (gimple_omp_for_final_ptr (stmt, i), callback_op, - wi, pset); - if (ret) - return ret; - ret = walk_tree (gimple_omp_for_incr_ptr (stmt, i), callback_op, - wi, pset); - } - if (ret) - return ret; + { + gomp_for *omp_for_stmt = as_a (stmt); + ret = walk_tree (gimple_omp_for_clauses_ptr (omp_for_stmt), callback_op, wi, + pset); + if (ret) + return ret; + for (i = 0; i < gimple_omp_for_collapse (omp_for_stmt); i++) + { + ret = walk_tree (gimple_omp_for_index_ptr (omp_for_stmt, i), + callback_op, wi, pset); + if (ret) + return ret; + ret = walk_tree (gimple_omp_for_initial_ptr (omp_for_stmt, i), + callback_op, wi, pset); + if (ret) + return ret; + ret = walk_tree (gimple_omp_for_final_ptr (omp_for_stmt, i), + callback_op, wi, pset); + if (ret) + return ret; + ret = walk_tree (gimple_omp_for_incr_ptr (omp_for_stmt, i), + callback_op, wi, pset); + } + if (ret) + return ret; + } break; case GIMPLE_OMP_PARALLEL: @@ -619,8 +622,9 @@ walk_gimple_stmt (gimple_stmt_iterator *gsi, walk_stmt_fn callback_stmt, break; case GIMPLE_OMP_FOR: - ret = walk_gimple_seq_mod (gimple_omp_for_pre_body_ptr (stmt), callback_stmt, - callback_op, wi); + ret = walk_gimple_seq_mod (gimple_omp_for_pre_body_ptr ( + as_a (stmt)), + callback_stmt, callback_op, wi); if (ret) return wi->callback_result; diff --git a/gcc/gimple.c b/gcc/gimple.c index 7021300..f02930d 100644 --- a/gcc/gimple.c +++ b/gcc/gimple.c @@ -1731,28 +1731,29 @@ gimple_copy (gimple stmt) break; case GIMPLE_OMP_FOR: - new_seq = gimple_seq_copy (gimple_omp_for_pre_body (stmt)); - gimple_omp_for_set_pre_body (copy, new_seq); - t = unshare_expr (gimple_omp_for_clauses (stmt)); - gimple_omp_for_set_clauses (copy, t); { + gomp_for *omp_for_stmt = as_a (stmt); gomp_for *omp_for_copy = as_a (copy); + new_seq = gimple_seq_copy (gimple_omp_for_pre_body (omp_for_stmt)); + gimple_omp_for_set_pre_body (omp_for_copy, new_seq); + t = unshare_expr (gimple_omp_for_clauses (omp_for_stmt)); + gimple_omp_for_set_clauses (omp_for_copy, t); omp_for_copy->iter = ggc_vec_alloc - ( gimple_omp_for_collapse (stmt)); - } - for (i = 0; i < gimple_omp_for_collapse (stmt); i++) - { - gimple_omp_for_set_cond (copy, i, - gimple_omp_for_cond (stmt, i)); - gimple_omp_for_set_index (copy, i, - gimple_omp_for_index (stmt, i)); - t = unshare_expr (gimple_omp_for_initial (stmt, i)); - gimple_omp_for_set_initial (copy, i, t); - t = unshare_expr (gimple_omp_for_final (stmt, i)); - gimple_omp_for_set_final (copy, i, t); - t = unshare_expr (gimple_omp_for_incr (stmt, i)); - gimple_omp_for_set_incr (copy, i, t); - } + ( gimple_omp_for_collapse (omp_for_stmt)); + for (i = 0; i < gimple_omp_for_collapse (omp_for_stmt); i++) + { + gimple_omp_for_set_cond (omp_for_copy, i, + gimple_omp_for_cond (omp_for_stmt, i)); + gimple_omp_for_set_index (omp_for_copy, i, + gimple_omp_for_index (omp_for_stmt, i)); + t = unshare_expr (gimple_omp_for_initial (omp_for_stmt, i)); + gimple_omp_for_set_initial (omp_for_copy, i, t); + t = unshare_expr (gimple_omp_for_final (omp_for_stmt, i)); + gimple_omp_for_set_final (omp_for_copy, i, t); + t = unshare_expr (gimple_omp_for_incr (omp_for_stmt, i)); + gimple_omp_for_set_incr (omp_for_copy, i, t); + } + } goto copy_omp_body; case GIMPLE_OMP_PARALLEL: diff --git a/gcc/gimple.h b/gcc/gimple.h index ef1f4f7..6df9dbf 100644 --- a/gcc/gimple.h +++ b/gcc/gimple.h @@ -4333,9 +4333,8 @@ gimple_omp_critical_set_name (gomp_critical *crit_stmt, tree name) /* Return the kind of OMP for statemement. */ static inline int -gimple_omp_for_kind (const_gimple g) +gimple_omp_for_kind (const gomp_for *g) { - GIMPLE_CHECK (g, GIMPLE_OMP_FOR); return (gimple_omp_subcode (g) & GF_OMP_FOR_KIND_MASK); } @@ -4354,9 +4353,8 @@ gimple_omp_for_set_kind (gomp_for *g, int kind) GF_OMP_FOR_COMBINED flag set. */ static inline bool -gimple_omp_for_combined_p (const_gimple g) +gimple_omp_for_combined_p (const gomp_for *g) { - GIMPLE_CHECK (g, GIMPLE_OMP_FOR); return (gimple_omp_subcode (g) & GF_OMP_FOR_COMBINED) != 0; } @@ -4378,9 +4376,8 @@ gimple_omp_for_set_combined_p (gomp_for *g, bool combined_p) GF_OMP_FOR_COMBINED_INTO flag set. */ static inline bool -gimple_omp_for_combined_into_p (const_gimple g) +gimple_omp_for_combined_into_p (const gomp_for *g) { - GIMPLE_CHECK (g, GIMPLE_OMP_FOR); return (gimple_omp_subcode (g) & GF_OMP_FOR_COMBINED_INTO) != 0; } @@ -4398,224 +4395,189 @@ gimple_omp_for_set_combined_into_p (gomp_for *g, bool combined_p) } -/* Return the clauses associated with OMP_FOR GS. */ +/* Return the clauses associated with OMP_FOR OMP_FOR_STMT. */ static inline tree -gimple_omp_for_clauses (const_gimple gs) +gimple_omp_for_clauses (const gomp_for *omp_for_stmt) { - const gomp_for *omp_for_stmt = - as_a (gs); return omp_for_stmt->clauses; } -/* Return a pointer to the OMP_FOR GS. */ +/* Return a pointer to the OMP_FOR OMP_FOR_STMT. */ static inline tree * -gimple_omp_for_clauses_ptr (gimple gs) +gimple_omp_for_clauses_ptr (gomp_for *omp_for_stmt) { - gomp_for *omp_for_stmt = - as_a (gs); return &omp_for_stmt->clauses; } -/* Set CLAUSES to be the list of clauses associated with OMP_FOR GS. */ +/* Set CLAUSES to be the list of clauses associated with OMP_FOR + OMP_FOR_STMT. */ static inline void -gimple_omp_for_set_clauses (gimple gs, tree clauses) +gimple_omp_for_set_clauses (gomp_for *omp_for_stmt, tree clauses) { - gomp_for *omp_for_stmt = - as_a (gs); omp_for_stmt->clauses = clauses; } -/* Get the collapse count of OMP_FOR GS. */ +/* Get the collapse count of OMP_FOR OMP_FOR_STMT. */ static inline size_t -gimple_omp_for_collapse (gimple gs) +gimple_omp_for_collapse (const gomp_for *omp_for_stmt) { - gomp_for *omp_for_stmt = - as_a (gs); return omp_for_stmt->collapse; } -/* Return the index variable for OMP_FOR GS. */ +/* Return the index variable for OMP_FOR OMP_FOR_STMT. */ static inline tree -gimple_omp_for_index (const_gimple gs, size_t i) +gimple_omp_for_index (const gomp_for *omp_for_stmt, size_t i) { - const gomp_for *omp_for_stmt = - as_a (gs); gcc_gimple_checking_assert (i < omp_for_stmt->collapse); return omp_for_stmt->iter[i].index; } -/* Return a pointer to the index variable for OMP_FOR GS. */ +/* Return a pointer to the index variable for OMP_FOR OMP_FOR_STMT. */ static inline tree * -gimple_omp_for_index_ptr (gimple gs, size_t i) +gimple_omp_for_index_ptr (gomp_for *omp_for_stmt, size_t i) { - gomp_for *omp_for_stmt = - as_a (gs); gcc_gimple_checking_assert (i < omp_for_stmt->collapse); return &omp_for_stmt->iter[i].index; } -/* Set INDEX to be the index variable for OMP_FOR GS. */ +/* Set INDEX to be the index variable for OMP_FOR OMP_FOR_STMT. */ static inline void -gimple_omp_for_set_index (gimple gs, size_t i, tree index) +gimple_omp_for_set_index (gomp_for *omp_for_stmt, size_t i, tree index) { - gomp_for *omp_for_stmt = - as_a (gs); gcc_gimple_checking_assert (i < omp_for_stmt->collapse); omp_for_stmt->iter[i].index = index; } -/* Return the initial value for OMP_FOR GS. */ +/* Return the initial value for OMP_FOR OMP_FOR_STMT. */ static inline tree -gimple_omp_for_initial (const_gimple gs, size_t i) +gimple_omp_for_initial (const gomp_for *omp_for_stmt, size_t i) { - const gomp_for *omp_for_stmt = - as_a (gs); gcc_gimple_checking_assert (i < omp_for_stmt->collapse); return omp_for_stmt->iter[i].initial; } -/* Return a pointer to the initial value for OMP_FOR GS. */ +/* Return a pointer to the initial value for OMP_FOR OMP_FOR_STMT. */ static inline tree * -gimple_omp_for_initial_ptr (gimple gs, size_t i) +gimple_omp_for_initial_ptr (gomp_for *omp_for_stmt, size_t i) { - gomp_for *omp_for_stmt = - as_a (gs); gcc_gimple_checking_assert (i < omp_for_stmt->collapse); return &omp_for_stmt->iter[i].initial; } -/* Set INITIAL to be the initial value for OMP_FOR GS. */ +/* Set INITIAL to be the initial value for OMP_FOR OMP_FOR_STMT. */ static inline void -gimple_omp_for_set_initial (gimple gs, size_t i, tree initial) +gimple_omp_for_set_initial (gomp_for *omp_for_stmt, size_t i, tree initial) { - gomp_for *omp_for_stmt = - as_a (gs); gcc_gimple_checking_assert (i < omp_for_stmt->collapse); omp_for_stmt->iter[i].initial = initial; } -/* Return the final value for OMP_FOR GS. */ +/* Return the final value for OMP_FOR OMP_FOR_STMT. */ static inline tree -gimple_omp_for_final (const_gimple gs, size_t i) +gimple_omp_for_final (const gomp_for *omp_for_stmt, size_t i) { - const gomp_for *omp_for_stmt = - as_a (gs); gcc_gimple_checking_assert (i < omp_for_stmt->collapse); return omp_for_stmt->iter[i].final; } -/* Return a pointer to the final value for OMP_FOR GS. */ +/* Return a pointer to the final value for OMP_FOR OMP_FOR_STMT. */ static inline tree * -gimple_omp_for_final_ptr (gimple gs, size_t i) +gimple_omp_for_final_ptr (gomp_for *omp_for_stmt, size_t i) { - gomp_for *omp_for_stmt = - as_a (gs); gcc_gimple_checking_assert (i < omp_for_stmt->collapse); return &omp_for_stmt->iter[i].final; } -/* Set FINAL to be the final value for OMP_FOR GS. */ +/* Set FINAL to be the final value for OMP_FOR OMP_FOR_STMT. */ static inline void -gimple_omp_for_set_final (gimple gs, size_t i, tree final) +gimple_omp_for_set_final (gomp_for *omp_for_stmt, size_t i, tree final) { - gomp_for *omp_for_stmt = - as_a (gs); gcc_gimple_checking_assert (i < omp_for_stmt->collapse); omp_for_stmt->iter[i].final = final; } -/* Return the increment value for OMP_FOR GS. */ +/* Return the increment value for OMP_FOR OMP_FOR_STMT. */ static inline tree -gimple_omp_for_incr (const_gimple gs, size_t i) +gimple_omp_for_incr (const gomp_for *omp_for_stmt, size_t i) { - const gomp_for *omp_for_stmt = - as_a (gs); gcc_gimple_checking_assert (i < omp_for_stmt->collapse); return omp_for_stmt->iter[i].incr; } -/* Return a pointer to the increment value for OMP_FOR GS. */ +/* Return a pointer to the increment value for OMP_FOR OMP_FOR_STMT. */ static inline tree * -gimple_omp_for_incr_ptr (gimple gs, size_t i) +gimple_omp_for_incr_ptr (gomp_for *omp_for_stmt, size_t i) { - gomp_for *omp_for_stmt = - as_a (gs); gcc_gimple_checking_assert (i < omp_for_stmt->collapse); return &omp_for_stmt->iter[i].incr; } -/* Set INCR to be the increment value for OMP_FOR GS. */ +/* Set INCR to be the increment value for OMP_FOR OMP_FOR_STMT. */ static inline void -gimple_omp_for_set_incr (gimple gs, size_t i, tree incr) +gimple_omp_for_set_incr (gomp_for *omp_for_stmt, size_t i, tree incr) { - gomp_for *omp_for_stmt = - as_a (gs); gcc_gimple_checking_assert (i < omp_for_stmt->collapse); omp_for_stmt->iter[i].incr = incr; } /* Return a pointer to the sequence of statements to execute before the OMP_FOR - statement GS starts. */ + statement OMP_FOR_STMT starts. */ static inline gimple_seq * -gimple_omp_for_pre_body_ptr (gimple gs) +gimple_omp_for_pre_body_ptr (gomp_for *omp_for_stmt) { - gomp_for *omp_for_stmt = - as_a (gs); return &omp_for_stmt->pre_body; } /* Return the sequence of statements to execute before the OMP_FOR - statement GS starts. */ + statement OMP_FOR_STMT starts. */ static inline gimple_seq -gimple_omp_for_pre_body (gimple gs) +gimple_omp_for_pre_body (gomp_for *omp_for_stmt) { - return *gimple_omp_for_pre_body_ptr (gs); + return *gimple_omp_for_pre_body_ptr (omp_for_stmt); } /* Set PRE_BODY to be the sequence of statements to execute before the - OMP_FOR statement GS starts. */ + OMP_FOR statement OMP_FOR_STMT starts. */ static inline void -gimple_omp_for_set_pre_body (gimple gs, gimple_seq pre_body) +gimple_omp_for_set_pre_body (gomp_for *omp_for_stmt, gimple_seq pre_body) { - gomp_for *omp_for_stmt = - as_a (gs); omp_for_stmt->pre_body = pre_body; } @@ -5216,26 +5178,22 @@ gimple_omp_sections_set_control (gimple gs, tree control) } -/* Set COND to be the condition code for OMP_FOR GS. */ +/* Set COND to be the condition code for OMP_FOR OMP_FOR_STMT. */ static inline void -gimple_omp_for_set_cond (gimple gs, size_t i, enum tree_code cond) +gimple_omp_for_set_cond (gomp_for *omp_for_stmt, size_t i, enum tree_code cond) { - gomp_for *omp_for_stmt = - as_a (gs); gcc_gimple_checking_assert (TREE_CODE_CLASS (cond) == tcc_comparison && i < omp_for_stmt->collapse); omp_for_stmt->iter[i].cond = cond; } -/* Return the condition code associated with OMP_FOR GS. */ +/* Return the condition code associated with OMP_FOR OMP_FOR_STMT. */ static inline enum tree_code -gimple_omp_for_cond (const_gimple gs, size_t i) +gimple_omp_for_cond (const gomp_for *omp_for_stmt, size_t i) { - const gomp_for *omp_for_stmt = - as_a (gs); gcc_gimple_checking_assert (i < omp_for_stmt->collapse); return omp_for_stmt->iter[i].cond; } diff --git a/gcc/omp-low.c b/gcc/omp-low.c index 2f28761..c43f5ea 100644 --- a/gcc/omp-low.c +++ b/gcc/omp-low.c @@ -785,7 +785,7 @@ determine_parallel_type (struct omp_region *region) parallel loop call would still need extra synchronization to implement ordered semantics, so there would not be any gain in using the combined call. */ - tree clauses = gimple_omp_for_clauses (ws_stmt); + tree clauses = gimple_omp_for_clauses (as_a (ws_stmt)); tree c = find_omp_clause (clauses, OMP_CLAUSE_SCHEDULE); if (c == NULL || OMP_CLAUSE_SCHEDULE_KIND (c) == OMP_CLAUSE_SCHEDULE_STATIC @@ -1034,7 +1034,8 @@ build_outer_var_ref (tree var, omp_context *ctx) x = build_receiver_ref (var, by_ref, ctx); } else if (gimple_code (ctx->stmt) == GIMPLE_OMP_FOR - && gimple_omp_for_kind (ctx->stmt) & GF_OMP_FOR_SIMD) + && (gimple_omp_for_kind (as_a (ctx->stmt)) + & GF_OMP_FOR_SIMD)) { /* #pragma omp simd isn't a worksharing construct, and can reference even private vars in its linear etc. clauses. */ @@ -2039,12 +2040,15 @@ find_combined_for (gimple_stmt_iterator *gsi_p, WALK_SUBSTMTS; case GIMPLE_OMP_FOR: - if (gimple_omp_for_combined_into_p (stmt) - && gimple_omp_for_kind (stmt) == GF_OMP_FOR_KIND_FOR) - { - wi->info = stmt; - return integer_zero_node; - } + { + gomp_for *omp_for_stmt = as_a (stmt); + if (gimple_omp_for_combined_into_p (omp_for_stmt) + && gimple_omp_for_kind (omp_for_stmt) == GF_OMP_FOR_KIND_FOR) + { + wi->info = stmt; + return integer_zero_node; + } + } break; default: break; @@ -2404,7 +2408,8 @@ check_omp_nesting_restrictions (gimple stmt, omp_context *ctx) if (ctx != NULL) { if (gimple_code (ctx->stmt) == GIMPLE_OMP_FOR - && gimple_omp_for_kind (ctx->stmt) & GF_OMP_FOR_SIMD) + && (gimple_omp_for_kind (as_a (ctx->stmt)) + & GF_OMP_FOR_SIMD)) { error_at (gimple_location (stmt), "OpenMP constructs may not be nested inside simd region"); @@ -2413,7 +2418,7 @@ check_omp_nesting_restrictions (gimple stmt, omp_context *ctx) else if (gimple_code (ctx->stmt) == GIMPLE_OMP_TEAMS) { if ((gimple_code (stmt) != GIMPLE_OMP_FOR - || (gimple_omp_for_kind (stmt) + || (gimple_omp_for_kind (as_a (stmt)) != GF_OMP_FOR_KIND_DISTRIBUTE)) && gimple_code (stmt) != GIMPLE_OMP_PARALLEL) { @@ -2427,19 +2432,22 @@ check_omp_nesting_restrictions (gimple stmt, omp_context *ctx) switch (gimple_code (stmt)) { case GIMPLE_OMP_FOR: - if (gimple_omp_for_kind (stmt) & GF_OMP_FOR_SIMD) - return true; - if (gimple_omp_for_kind (stmt) == GF_OMP_FOR_KIND_DISTRIBUTE) - { - if (ctx != NULL && gimple_code (ctx->stmt) != GIMPLE_OMP_TEAMS) - { - error_at (gimple_location (stmt), - "distribute construct must be closely nested inside " - "teams construct"); - return false; - } + { + gomp_for *omp_for_stmt = as_a (stmt); + if (gimple_omp_for_kind (omp_for_stmt) & GF_OMP_FOR_SIMD) return true; - } + if (gimple_omp_for_kind (omp_for_stmt) == GF_OMP_FOR_KIND_DISTRIBUTE) + { + if (ctx != NULL && gimple_code (ctx->stmt) != GIMPLE_OMP_TEAMS) + { + error_at (gimple_location (stmt), + "distribute construct must be closely nested inside " + "teams construct"); + return false; + } + return true; + } + } /* FALLTHRU */ case GIMPLE_CALL: if (is_gimple_call (stmt) @@ -2474,19 +2482,22 @@ check_omp_nesting_restrictions (gimple stmt, omp_context *ctx) break; case 2: if (gimple_code (ctx->stmt) != GIMPLE_OMP_FOR - || gimple_omp_for_kind (ctx->stmt) != GF_OMP_FOR_KIND_FOR) + || (gimple_omp_for_kind (as_a (ctx->stmt)) + != GF_OMP_FOR_KIND_FOR)) bad = "#pragma omp for"; else if (DECL_FUNCTION_CODE (gimple_call_fndecl (stmt)) == BUILT_IN_GOMP_CANCEL && !integer_zerop (gimple_call_arg (stmt, 1))) { ctx->cancellable = true; - if (find_omp_clause (gimple_omp_for_clauses (ctx->stmt), + if (find_omp_clause (gimple_omp_for_clauses ( + as_a (ctx->stmt)), OMP_CLAUSE_NOWAIT)) warning_at (gimple_location (stmt), 0, "%<#pragma omp cancel for%> inside " "% for construct"); - if (find_omp_clause (gimple_omp_for_clauses (ctx->stmt), + if (find_omp_clause (gimple_omp_for_clauses ( + as_a (ctx->stmt)), OMP_CLAUSE_ORDERED)) warning_at (gimple_location (stmt), 0, "%<#pragma omp cancel for%> inside " @@ -2614,7 +2625,8 @@ check_omp_nesting_restrictions (gimple stmt, omp_context *ctx) "of critical or explicit task region"); return false; case GIMPLE_OMP_FOR: - if (find_omp_clause (gimple_omp_for_clauses (ctx->stmt), + if (find_omp_clause (gimple_omp_for_clauses ( + as_a (ctx->stmt)), OMP_CLAUSE_ORDERED) == NULL) { error_at (gimple_location (stmt), @@ -2774,7 +2786,8 @@ scan_omp_1_stmt (gimple_stmt_iterator *gsi, bool *handled_ops_p, if (setjmp_or_longjmp_p (fndecl) && ctx && gimple_code (ctx->stmt) == GIMPLE_OMP_FOR - && gimple_omp_for_kind (ctx->stmt) & GF_OMP_FOR_SIMD) + && (gimple_omp_for_kind (as_a (ctx->stmt)) + & GF_OMP_FOR_SIMD)) { remove = true; error_at (gimple_location (stmt), @@ -3141,7 +3154,8 @@ lower_rec_simd_input_clauses (tree new_var, omp_context *ctx, int &max_vf, max_vf = omp_max_vf (); if (max_vf > 1) { - tree c = find_omp_clause (gimple_omp_for_clauses (ctx->stmt), + tree c = find_omp_clause (gimple_omp_for_clauses ( + as_a (ctx->stmt)), OMP_CLAUSE_SAFELEN); if (c && TREE_CODE (OMP_CLAUSE_SAFELEN_EXPR (c)) != INTEGER_CST) max_vf = 1; @@ -3214,7 +3228,8 @@ lower_rec_input_clauses (tree clauses, gimple_seq *ilist, gimple_seq *dlist, bool reduction_omp_orig_ref = false; int pass; bool is_simd = (gimple_code (ctx->stmt) == GIMPLE_OMP_FOR - && gimple_omp_for_kind (ctx->stmt) & GF_OMP_FOR_SIMD); + && (gimple_omp_for_kind (as_a (ctx->stmt)) + & GF_OMP_FOR_SIMD)); int max_vf = 0; tree lane = NULL_TREE, idx = NULL_TREE; tree ivar = NULL_TREE, lvar = NULL_TREE; @@ -3561,7 +3576,8 @@ lower_rec_input_clauses (tree clauses, gimple_seq *ilist, gimple_seq *dlist, if (is_simd) { if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_LINEAR - && gimple_omp_for_combined_into_p (ctx->stmt)) + && gimple_omp_for_combined_into_p ( + as_a (ctx->stmt))) { tree t = OMP_CLAUSE_LINEAR_STEP (c); tree stept = TREE_TYPE (t); @@ -3612,7 +3628,8 @@ lower_rec_input_clauses (tree clauses, gimple_seq *ilist, gimple_seq *dlist, x = lang_hooks.decls.omp_clause_copy_ctor (c, iv, x); gimplify_and_add (x, ilist); gimple_stmt_iterator gsi - = gsi_start_1 (gimple_omp_body_ptr (ctx->stmt)); + = gsi_start_1 (gimple_omp_body_ptr ( + as_a (ctx->stmt))); gassign *g = gimple_build_assign (unshare_expr (lvar), iv); gsi_insert_before_without_update (&gsi, g, @@ -3829,8 +3846,9 @@ lower_rec_input_clauses (tree clauses, gimple_seq *ilist, gimple_seq *dlist, gsi_insert_before_without_update (&gsi, g, GSI_SAME_STMT); c = build_omp_clause (UNKNOWN_LOCATION, OMP_CLAUSE__SIMDUID_); OMP_CLAUSE__SIMDUID__DECL (c) = uid; - OMP_CLAUSE_CHAIN (c) = gimple_omp_for_clauses (ctx->stmt); - gimple_omp_for_set_clauses (ctx->stmt, c); + gomp_for *omp_for_ctx_stmt = as_a (ctx->stmt); + OMP_CLAUSE_CHAIN (c) = gimple_omp_for_clauses (omp_for_ctx_stmt); + gimple_omp_for_set_clauses (omp_for_ctx_stmt, c); g = gimple_build_assign_with_ops (INTEGER_CST, lane, build_int_cst (unsigned_type_node, 0), NULL_TREE); @@ -3886,7 +3904,8 @@ lower_rec_input_clauses (tree clauses, gimple_seq *ilist, gimple_seq *dlist, /* Don't add any barrier for #pragma omp simd or #pragma omp distribute. */ if (gimple_code (ctx->stmt) != GIMPLE_OMP_FOR - || gimple_omp_for_kind (ctx->stmt) == GF_OMP_FOR_KIND_FOR) + || (gimple_omp_for_kind (as_a (ctx->stmt)) + == GF_OMP_FOR_KIND_FOR)) gimple_seq_add_stmt (ilist, build_omp_barrier (NULL_TREE)); } @@ -3894,7 +3913,8 @@ lower_rec_input_clauses (tree clauses, gimple_seq *ilist, gimple_seq *dlist, up to the max_vf we chose. So stick it into the safelen clause. */ if (max_vf) { - tree c = find_omp_clause (gimple_omp_for_clauses (ctx->stmt), + gomp_for *omp_for_ctx_stmt = as_a (ctx->stmt); + tree c = find_omp_clause (gimple_omp_for_clauses (omp_for_ctx_stmt), OMP_CLAUSE_SAFELEN); if (c == NULL_TREE || (TREE_CODE (OMP_CLAUSE_SAFELEN_EXPR (c)) == INTEGER_CST @@ -3904,8 +3924,8 @@ lower_rec_input_clauses (tree clauses, gimple_seq *ilist, gimple_seq *dlist, c = build_omp_clause (UNKNOWN_LOCATION, OMP_CLAUSE_SAFELEN); OMP_CLAUSE_SAFELEN_EXPR (c) = build_int_cst (integer_type_node, max_vf); - OMP_CLAUSE_CHAIN (c) = gimple_omp_for_clauses (ctx->stmt); - gimple_omp_for_set_clauses (ctx->stmt, c); + OMP_CLAUSE_CHAIN (c) = gimple_omp_for_clauses (omp_for_ctx_stmt); + gimple_omp_for_set_clauses (omp_for_ctx_stmt, c); } } } @@ -3966,7 +3986,7 @@ lower_lastprivate_clauses (tree clauses, tree predicate, gimple_seq *stmt_list, } if (gimple_code (ctx->stmt) == GIMPLE_OMP_FOR - && gimple_omp_for_kind (ctx->stmt) & GF_OMP_FOR_SIMD) + && gimple_omp_for_kind (as_a (ctx->stmt)) & GF_OMP_FOR_SIMD) { simduid = find_omp_clause (orig_clauses, OMP_CLAUSE__SIMDUID_); if (simduid) @@ -4069,7 +4089,7 @@ lower_reduction_clauses (tree clauses, gimple_seq *stmt_seqp, omp_context *ctx) /* SIMD reductions are handled in lower_rec_input_clauses. */ if (gimple_code (ctx->stmt) == GIMPLE_OMP_FOR - && gimple_omp_for_kind (ctx->stmt) & GF_OMP_FOR_SIMD) + && gimple_omp_for_kind (as_a (ctx->stmt)) & GF_OMP_FOR_SIMD) return; /* First see if there is exactly one reduction clause. Use OMP_ATOMIC @@ -5355,7 +5375,7 @@ expand_omp_for_init_vars (struct omp_for_data *fd, gimple_stmt_iterator *gsi, tree clauses = gimple_code (inner_stmt) == GIMPLE_OMP_PARALLEL ? gimple_omp_parallel_clauses (inner_stmt) - : gimple_omp_for_clauses (inner_stmt); + : gimple_omp_for_clauses (as_a (inner_stmt)); /* First two _looptemp_ clauses are for istart/iend, counts[0] isn't supposed to be handled, as the inner loop doesn't use it. */ @@ -5802,10 +5822,12 @@ expand_omp_for_generic (struct omp_region *region, if (gimple_omp_for_combined_p (fd->for_stmt)) { - gcc_assert (gimple_code (inner_stmt) == GIMPLE_OMP_FOR - && gimple_omp_for_kind (inner_stmt) - == GF_OMP_FOR_KIND_SIMD); - tree innerc = find_omp_clause (gimple_omp_for_clauses (inner_stmt), + gcc_assert (gimple_code (inner_stmt) == GIMPLE_OMP_FOR); + gomp_for *omp_for_inner_stmt = as_a (inner_stmt); + gcc_assert (gimple_omp_for_kind (omp_for_inner_stmt) + == GF_OMP_FOR_KIND_SIMD); + tree innerc = find_omp_clause (gimple_omp_for_clauses ( + omp_for_inner_stmt), OMP_CLAUSE__LOOPTEMP_); gcc_assert (innerc); startvar = OMP_CLAUSE_DECL (innerc); @@ -6227,7 +6249,7 @@ expand_omp_for_static_nochunk (struct omp_region *region, { tree clauses = gimple_code (inner_stmt) == GIMPLE_OMP_PARALLEL ? gimple_omp_parallel_clauses (inner_stmt) - : gimple_omp_for_clauses (inner_stmt); + : gimple_omp_for_clauses (as_a (inner_stmt)); tree innerc = find_omp_clause (clauses, OMP_CLAUSE__LOOPTEMP_); gcc_assert (innerc); startvar = OMP_CLAUSE_DECL (innerc); @@ -6618,7 +6640,7 @@ expand_omp_for_static_chunk (struct omp_region *region, { tree clauses = gimple_code (inner_stmt) == GIMPLE_OMP_PARALLEL ? gimple_omp_parallel_clauses (inner_stmt) - : gimple_omp_for_clauses (inner_stmt); + : gimple_omp_for_clauses (as_a (inner_stmt)); tree innerc = find_omp_clause (clauses, OMP_CLAUSE__LOOPTEMP_); gcc_assert (innerc); startvar = OMP_CLAUSE_DECL (innerc); @@ -7335,13 +7357,13 @@ expand_omp_for (struct omp_region *region, gimple inner_stmt) { struct omp_for_data fd; struct omp_for_data_loop *loops; + gomp_for *omp_for_stmt = as_a (last_stmt (region->entry)); loops = (struct omp_for_data_loop *) - alloca (gimple_omp_for_collapse (last_stmt (region->entry)) + alloca (gimple_omp_for_collapse (omp_for_stmt) * sizeof (struct omp_for_data_loop)); - extract_omp_for_data (as_a (last_stmt (region->entry)), - &fd, loops); + extract_omp_for_data (omp_for_stmt, &fd, loops); region->sched_kind = fd.sched_kind; gcc_assert (EDGE_COUNT (region->entry->succs) == 2); @@ -8603,7 +8625,8 @@ expand_omp (struct omp_region *region) determine_parallel_type (region); if (region->type == GIMPLE_OMP_FOR - && gimple_omp_for_combined_p (last_stmt (region->entry))) + && gimple_omp_for_combined_p ( + as_a (last_stmt (region->entry)))) inner_stmt = last_stmt (region->inner->entry); if (region->inner) @@ -10808,10 +10831,12 @@ diagnose_sb_0 (gimple_stmt_iterator *gsi_p, { if ((branch_ctx && gimple_code (branch_ctx) == GIMPLE_OMP_FOR - && gimple_omp_for_kind (branch_ctx) == GF_OMP_FOR_KIND_CILKSIMD) + && (gimple_omp_for_kind (as_a (branch_ctx)) + == GF_OMP_FOR_KIND_CILKSIMD)) || (label_ctx && gimple_code (label_ctx) == GIMPLE_OMP_FOR - && gimple_omp_for_kind (label_ctx) == GF_OMP_FOR_KIND_CILKSIMD)) + && (gimple_omp_for_kind (as_a (label_ctx)) + == GF_OMP_FOR_KIND_CILKSIMD))) cilkplus_block = true; } @@ -10872,14 +10897,18 @@ diagnose_sb_1 (gimple_stmt_iterator *gsi_p, bool *handled_ops_p, break; case GIMPLE_OMP_FOR: - inner_context = stmt; - wi->info = inner_context; - /* gimple_omp_for_{index,initial,final} are all DECLs; no need to - walk them. */ - walk_gimple_seq (gimple_omp_for_pre_body (stmt), - diagnose_sb_1, NULL, wi); - walk_gimple_seq (gimple_omp_body (stmt), diagnose_sb_1, NULL, wi); - wi->info = context; + { + gomp_for *omp_for_stmt = as_a (stmt); + inner_context = stmt; + wi->info = inner_context; + /* gimple_omp_for_{index,initial,final} are all DECLs; no need to + walk them. */ + walk_gimple_seq (gimple_omp_for_pre_body (omp_for_stmt), + diagnose_sb_1, NULL, wi); + walk_gimple_seq (gimple_omp_body (omp_for_stmt), diagnose_sb_1, NULL, + wi); + wi->info = context; + } break; case GIMPLE_LABEL: @@ -10930,13 +10959,17 @@ diagnose_sb_2 (gimple_stmt_iterator *gsi_p, bool *handled_ops_p, break; case GIMPLE_OMP_FOR: - wi->info = stmt; - /* gimple_omp_for_{index,initial,final} are all DECLs; no need to - walk them. */ - walk_gimple_seq_mod (gimple_omp_for_pre_body_ptr (stmt), - diagnose_sb_2, NULL, wi); - walk_gimple_seq_mod (gimple_omp_body_ptr (stmt), diagnose_sb_2, NULL, wi); - wi->info = context; + { + gomp_for *omp_for_stmt = as_a (stmt); + wi->info = stmt; + /* gimple_omp_for_{index,initial,final} are all DECLs; no need to + walk them. */ + walk_gimple_seq_mod (gimple_omp_for_pre_body_ptr (omp_for_stmt), + diagnose_sb_2, NULL, wi); + walk_gimple_seq_mod (gimple_omp_body_ptr (omp_for_stmt), diagnose_sb_2, + NULL, wi); + wi->info = context; + } break; case GIMPLE_COND: diff --git a/gcc/tree-inline.c b/gcc/tree-inline.c index 8688a99..fd20bcb 100644 --- a/gcc/tree-inline.c +++ b/gcc/tree-inline.c @@ -1402,25 +1402,34 @@ remap_gimple_stmt (gimple stmt, copy_body_data *id) break; case GIMPLE_OMP_FOR: - s1 = remap_gimple_seq (gimple_omp_body (stmt), id); - s2 = remap_gimple_seq (gimple_omp_for_pre_body (stmt), id); - copy = gimple_build_omp_for (s1, gimple_omp_for_kind (stmt), - gimple_omp_for_clauses (stmt), - gimple_omp_for_collapse (stmt), s2); { + gomp_for *omp_for_stmt = as_a (stmt); + gomp_for *omp_for_copy; size_t i; - for (i = 0; i < gimple_omp_for_collapse (stmt); i++) + s1 = remap_gimple_seq (gimple_omp_body (omp_for_stmt), id); + s2 = remap_gimple_seq (gimple_omp_for_pre_body (omp_for_stmt), id); + copy = omp_for_copy = + gimple_build_omp_for (s1, gimple_omp_for_kind (omp_for_stmt), + gimple_omp_for_clauses (omp_for_stmt), + gimple_omp_for_collapse (omp_for_stmt), + s2); + for (i = 0; i < gimple_omp_for_collapse (omp_for_stmt); i++) { - gimple_omp_for_set_index (copy, i, - gimple_omp_for_index (stmt, i)); - gimple_omp_for_set_initial (copy, i, - gimple_omp_for_initial (stmt, i)); - gimple_omp_for_set_final (copy, i, - gimple_omp_for_final (stmt, i)); - gimple_omp_for_set_incr (copy, i, - gimple_omp_for_incr (stmt, i)); - gimple_omp_for_set_cond (copy, i, - gimple_omp_for_cond (stmt, i)); + gimple_omp_for_set_index (omp_for_copy, i, + gimple_omp_for_index (omp_for_stmt, + i)); + gimple_omp_for_set_initial (omp_for_copy, i, + gimple_omp_for_initial ( + omp_for_stmt, i)); + gimple_omp_for_set_final (omp_for_copy, i, + gimple_omp_for_final (omp_for_stmt, + i)); + gimple_omp_for_set_incr (omp_for_copy, i, + gimple_omp_for_incr (omp_for_stmt, + i)); + gimple_omp_for_set_cond (omp_for_copy, i, + gimple_omp_for_cond (omp_for_stmt, + i)); } } break; @@ -4036,9 +4045,14 @@ estimate_num_insns (gimple stmt, eni_weights *weights) return weights->omp_cost; case GIMPLE_OMP_FOR: - return (weights->omp_cost - + estimate_num_insns_seq (gimple_omp_body (stmt), weights) - + estimate_num_insns_seq (gimple_omp_for_pre_body (stmt), weights)); + { + gomp_for *omp_for_stmt = as_a (stmt); + return (weights->omp_cost + + estimate_num_insns_seq (gimple_omp_body (omp_for_stmt), + weights) + + estimate_num_insns_seq (gimple_omp_for_pre_body (omp_for_stmt), + weights)); + } case GIMPLE_OMP_PARALLEL: case GIMPLE_OMP_TASK: diff --git a/gcc/tree-nested.c b/gcc/tree-nested.c index c95fe81..95ecbc0 100644 --- a/gcc/tree-nested.c +++ b/gcc/tree-nested.c @@ -1350,14 +1350,18 @@ convert_nonlocal_reference_stmt (gimple_stmt_iterator *gsi, bool *handled_ops_p, break; case GIMPLE_OMP_FOR: - save_suppress = info->suppress_expansion; - convert_nonlocal_omp_clauses (gimple_omp_for_clauses_ptr (stmt), wi); - walk_gimple_omp_for (as_a (stmt), - convert_nonlocal_reference_stmt, - convert_nonlocal_reference_op, info); - walk_body (convert_nonlocal_reference_stmt, - convert_nonlocal_reference_op, info, gimple_omp_body_ptr (stmt)); - info->suppress_expansion = save_suppress; + { + gomp_for *omp_for_stmt = as_a (stmt); + save_suppress = info->suppress_expansion; + convert_nonlocal_omp_clauses (gimple_omp_for_clauses_ptr (omp_for_stmt), wi); + walk_gimple_omp_for (omp_for_stmt, + convert_nonlocal_reference_stmt, + convert_nonlocal_reference_op, info); + walk_body (convert_nonlocal_reference_stmt, + convert_nonlocal_reference_op, info, + gimple_omp_body_ptr (omp_for_stmt)); + info->suppress_expansion = save_suppress; + } break; case GIMPLE_OMP_SECTIONS: @@ -1919,14 +1923,18 @@ convert_local_reference_stmt (gimple_stmt_iterator *gsi, bool *handled_ops_p, break; case GIMPLE_OMP_FOR: - save_suppress = info->suppress_expansion; - convert_local_omp_clauses (gimple_omp_for_clauses_ptr (stmt), wi); - walk_gimple_omp_for (as_a (stmt), - convert_local_reference_stmt, - convert_local_reference_op, info); - walk_body (convert_local_reference_stmt, convert_local_reference_op, - info, gimple_omp_body_ptr (stmt)); - info->suppress_expansion = save_suppress; + { + gomp_for *omp_for_stmt = as_a (stmt); + save_suppress = info->suppress_expansion; + convert_local_omp_clauses (gimple_omp_for_clauses_ptr (omp_for_stmt), + wi); + walk_gimple_omp_for (omp_for_stmt, + convert_local_reference_stmt, + convert_local_reference_op, info); + walk_body (convert_local_reference_stmt, convert_local_reference_op, + info, gimple_omp_body_ptr (omp_for_stmt)); + info->suppress_expansion = save_suppress; + } break; case GIMPLE_OMP_SECTIONS: @@ -2416,7 +2424,7 @@ convert_gimple_call (gimple_stmt_iterator *gsi, bool *handled_ops_p, case GIMPLE_OMP_FOR: walk_body (convert_gimple_call, NULL, info, - gimple_omp_for_pre_body_ptr (stmt)); + gimple_omp_for_pre_body_ptr (as_a (stmt))); /* FALLTHRU */ case GIMPLE_OMP_SECTIONS: case GIMPLE_OMP_SECTION: