This corresponds to: [PATCH 34/89] Introduce gimple_omp_atomic_load https://gcc.gnu.org/ml/gcc-patches/2014-04/msg01155.html from the original 89-patch kit
That earlier patch was approved by Jeff: > OK with expected changes due to renaming/updates to const handling. > Please repost the final patch for archival purposes. in https://gcc.gnu.org/ml/gcc-patches/2014-05/msg00802.html gcc/ * coretypes.h (gimple_omp_atomic_load): New typedef. (const_gimple_omp_atomic_load): New typedef. * gimple-pretty-print.c (dump_gimple_omp_atomic_load): Require a gimple_omp_atomic_load rather than a plain gimple. (pp_gimple_stmt_1): Add a checked cast to gimple_omp_atomic_load within GIMPLE_OMP_ATOMIC_LOAD case of switch statement. * gimple-walk.c (walk_gimple_op): Likewise, introducing a new local. * gimple.c (gimple_build_omp_atomic_load): Return a gimple_omp_atomic_load rather than a plain gimple. * gimple.h (gimple_build_omp_atomic_load): Return a gimple_omp_atomic_load rather than a plain gimple. (gimple_omp_atomic_load_set_lhs): Require a gimple_omp_atomic_load rather than a plain gimple. (gimple_omp_atomic_load_lhs_ptr): Likewise. (gimple_omp_atomic_load_set_rhs): Likewise. (gimple_omp_atomic_load_rhs_ptr): Likewise. (gimple_omp_atomic_load_lhs): Require a const_gimple_omp_atomic_load rather than a plain const_gimple. (gimple_omp_atomic_load_rhs): Likewise. * gimplify-me.c (gimple_regimplify_operands): Add a checked cast to gimple_omp_atomic_load within GIMPLE_OMP_ATOMIC_LOAD case of switch statement. * omp-low.c (expand_omp_atomic): Strengthen type of local "load" from gimple to gimple_omp_atomic_load. (lower_omp_1): Add a checked cast to gimple_omp_atomic_load within GIMPLE_OMP_ATOMIC_LOAD case of switch statement. --- gcc/ChangeLog.gimple-classes | 37 +++++++++++++++++++++++++++++++++++++ gcc/coretypes.h | 5 +++++ gcc/gimple-pretty-print.c | 8 ++++---- gcc/gimple-walk.c | 19 +++++++++++-------- gcc/gimple.c | 5 +++-- gcc/gimple.h | 38 +++++++++++++------------------------- gcc/gimplify-me.c | 5 +++-- gcc/omp-low.c | 7 +++++-- 8 files changed, 81 insertions(+), 43 deletions(-) diff --git a/gcc/ChangeLog.gimple-classes b/gcc/ChangeLog.gimple-classes index 5e6b383..3026787 100644 --- a/gcc/ChangeLog.gimple-classes +++ b/gcc/ChangeLog.gimple-classes @@ -1,5 +1,42 @@ 2014-10-24 David Malcolm <dmalc...@redhat.com> + Introduce gimple_omp_atomic_load + + * coretypes.h (gimple_omp_atomic_load): New typedef. + (const_gimple_omp_atomic_load): New typedef. + + * gimple-pretty-print.c (dump_gimple_omp_atomic_load): Require a + gimple_omp_atomic_load rather than a plain gimple. + (pp_gimple_stmt_1): Add a checked cast to gimple_omp_atomic_load + within GIMPLE_OMP_ATOMIC_LOAD case of switch statement. + + * gimple-walk.c (walk_gimple_op): Likewise, introducing a new local. + + * gimple.c (gimple_build_omp_atomic_load): Return a + gimple_omp_atomic_load rather than a plain gimple. + + * gimple.h (gimple_build_omp_atomic_load): Return a + gimple_omp_atomic_load rather than a plain gimple. + (gimple_omp_atomic_load_set_lhs): Require a + gimple_omp_atomic_load rather than a plain gimple. + (gimple_omp_atomic_load_lhs_ptr): Likewise. + (gimple_omp_atomic_load_set_rhs): Likewise. + (gimple_omp_atomic_load_rhs_ptr): Likewise. + (gimple_omp_atomic_load_lhs): Require a + const_gimple_omp_atomic_load rather than a plain const_gimple. + (gimple_omp_atomic_load_rhs): Likewise. + + * gimplify-me.c (gimple_regimplify_operands): Add a checked cast + to gimple_omp_atomic_load within GIMPLE_OMP_ATOMIC_LOAD case of + switch statement. + + * omp-low.c (expand_omp_atomic): Strengthen type of local "load" + from gimple to gimple_omp_atomic_load. + (lower_omp_1): Add a checked cast to gimple_omp_atomic_load within + GIMPLE_OMP_ATOMIC_LOAD case of switch statement. + +2014-10-24 David Malcolm <dmalc...@redhat.com> + Use more concrete types for various gimple statements * cgraphunit.c (thunk_adjust): Strengthen local "stmt" from gimple diff --git a/gcc/coretypes.h b/gcc/coretypes.h index e24a08e..06b3be8 100644 --- a/gcc/coretypes.h +++ b/gcc/coretypes.h @@ -166,6 +166,11 @@ struct gimple_statement_try; typedef struct gimple_statement_try *gimple_try; typedef const struct gimple_statement_try *const_gimple_try; +struct gimple_statement_omp_atomic_load; +typedef struct gimple_statement_omp_atomic_load *gimple_omp_atomic_load; +typedef const struct gimple_statement_omp_atomic_load * + const_gimple_omp_atomic_load; + union section; typedef union section section; struct gcc_options; diff --git a/gcc/gimple-pretty-print.c b/gcc/gimple-pretty-print.c index a1db8be..eafb6cd 100644 --- a/gcc/gimple-pretty-print.c +++ b/gcc/gimple-pretty-print.c @@ -1967,8 +1967,8 @@ dump_gimple_omp_task (pretty_printer *buffer, gimple gs, int spc, in dumpfile.h). */ static void -dump_gimple_omp_atomic_load (pretty_printer *buffer, gimple gs, int spc, - int flags) +dump_gimple_omp_atomic_load (pretty_printer *buffer, gimple_omp_atomic_load gs, + int spc, int flags) { if (flags & TDF_RAW) { @@ -2144,8 +2144,8 @@ pp_gimple_stmt_1 (pretty_printer *buffer, gimple gs, int spc, int flags) break; case GIMPLE_OMP_ATOMIC_LOAD: - dump_gimple_omp_atomic_load (buffer, gs, spc, flags); - + dump_gimple_omp_atomic_load (buffer, as_a <gimple_omp_atomic_load> (gs), + spc, flags); break; case GIMPLE_OMP_ATOMIC_STORE: diff --git a/gcc/gimple-walk.c b/gcc/gimple-walk.c index d36263a..af67218 100644 --- a/gcc/gimple-walk.c +++ b/gcc/gimple-walk.c @@ -419,15 +419,18 @@ walk_gimple_op (gimple stmt, walk_tree_fn callback_op, break; case GIMPLE_OMP_ATOMIC_LOAD: - ret = walk_tree (gimple_omp_atomic_load_lhs_ptr (stmt), callback_op, wi, - pset); - if (ret) - return ret; + { + gimple_omp_atomic_load omp_stmt = as_a <gimple_omp_atomic_load> (stmt); + ret = walk_tree (gimple_omp_atomic_load_lhs_ptr (omp_stmt), + callback_op, wi, pset); + if (ret) + return ret; - ret = walk_tree (gimple_omp_atomic_load_rhs_ptr (stmt), callback_op, wi, - pset); - if (ret) - return ret; + ret = walk_tree (gimple_omp_atomic_load_rhs_ptr (omp_stmt), + callback_op, wi, pset); + if (ret) + return ret; + } break; case GIMPLE_OMP_ATOMIC_STORE: diff --git a/gcc/gimple.c b/gcc/gimple.c index 2b00869..8672b83 100644 --- a/gcc/gimple.c +++ b/gcc/gimple.c @@ -1080,10 +1080,11 @@ gimple_build_omp_teams (gimple_seq body, tree clauses) /* Build a GIMPLE_OMP_ATOMIC_LOAD statement. */ -gimple +gimple_omp_atomic_load gimple_build_omp_atomic_load (tree lhs, tree rhs) { - gimple p = gimple_alloc (GIMPLE_OMP_ATOMIC_LOAD, 0); + gimple_omp_atomic_load p = + as_a <gimple_omp_atomic_load> (gimple_alloc (GIMPLE_OMP_ATOMIC_LOAD, 0)); gimple_omp_atomic_load_set_lhs (p, lhs); gimple_omp_atomic_load_set_rhs (p, rhs); return p; diff --git a/gcc/gimple.h b/gcc/gimple.h index f1af63a..a302529 100644 --- a/gcc/gimple.h +++ b/gcc/gimple.h @@ -1357,7 +1357,7 @@ gimple gimple_build_omp_sections_switch (void); gimple gimple_build_omp_single (gimple_seq, tree); gimple gimple_build_omp_target (gimple_seq, int, tree); gimple gimple_build_omp_teams (gimple_seq, tree); -gimple gimple_build_omp_atomic_load (tree, tree); +gimple_omp_atomic_load gimple_build_omp_atomic_load (tree, tree); gimple gimple_build_omp_atomic_store (tree); gimple_transaction gimple_build_transaction (gimple_seq, tree); gimple gimple_build_predict (enum br_predictor, enum prediction); @@ -5400,66 +5400,54 @@ gimple_omp_atomic_store_val_ptr (gimple g) /* Set the LHS of an atomic load. */ static inline void -gimple_omp_atomic_load_set_lhs (gimple g, tree lhs) +gimple_omp_atomic_load_set_lhs (gimple_omp_atomic_load load_stmt, tree lhs) { - gimple_statement_omp_atomic_load *omp_atomic_load_stmt = - as_a <gimple_statement_omp_atomic_load *> (g); - omp_atomic_load_stmt->lhs = lhs; + load_stmt->lhs = lhs; } /* Get the LHS of an atomic load. */ static inline tree -gimple_omp_atomic_load_lhs (const_gimple g) +gimple_omp_atomic_load_lhs (const_gimple_omp_atomic_load load_stmt) { - const gimple_statement_omp_atomic_load *omp_atomic_load_stmt = - as_a <const gimple_statement_omp_atomic_load *> (g); - return omp_atomic_load_stmt->lhs; + return load_stmt->lhs; } /* Return a pointer to the LHS of an atomic load. */ static inline tree * -gimple_omp_atomic_load_lhs_ptr (gimple g) +gimple_omp_atomic_load_lhs_ptr (gimple_omp_atomic_load load_stmt) { - gimple_statement_omp_atomic_load *omp_atomic_load_stmt = - as_a <gimple_statement_omp_atomic_load *> (g); - return &omp_atomic_load_stmt->lhs; + return &load_stmt->lhs; } /* Set the RHS of an atomic load. */ static inline void -gimple_omp_atomic_load_set_rhs (gimple g, tree rhs) +gimple_omp_atomic_load_set_rhs (gimple_omp_atomic_load load_stmt, tree rhs) { - gimple_statement_omp_atomic_load *omp_atomic_load_stmt = - as_a <gimple_statement_omp_atomic_load *> (g); - omp_atomic_load_stmt->rhs = rhs; + load_stmt->rhs = rhs; } /* Get the RHS of an atomic load. */ static inline tree -gimple_omp_atomic_load_rhs (const_gimple g) +gimple_omp_atomic_load_rhs (const_gimple_omp_atomic_load load_stmt) { - const gimple_statement_omp_atomic_load *omp_atomic_load_stmt = - as_a <const gimple_statement_omp_atomic_load *> (g); - return omp_atomic_load_stmt->rhs; + return load_stmt->rhs; } /* Return a pointer to the RHS of an atomic load. */ static inline tree * -gimple_omp_atomic_load_rhs_ptr (gimple g) +gimple_omp_atomic_load_rhs_ptr (gimple_omp_atomic_load load_stmt) { - gimple_statement_omp_atomic_load *omp_atomic_load_stmt = - as_a <gimple_statement_omp_atomic_load *> (g); - return &omp_atomic_load_stmt->rhs; + return &load_stmt->rhs; } diff --git a/gcc/gimplify-me.c b/gcc/gimplify-me.c index 08d2b9c..67d71fc 100644 --- a/gcc/gimplify-me.c +++ b/gcc/gimplify-me.c @@ -178,8 +178,9 @@ gimple_regimplify_operands (gimple stmt, gimple_stmt_iterator *gsi_p) is_gimple_val, fb_rvalue); break; case GIMPLE_OMP_ATOMIC_LOAD: - gimplify_expr (gimple_omp_atomic_load_rhs_ptr (stmt), &pre, NULL, - is_gimple_val, fb_rvalue); + gimplify_expr (gimple_omp_atomic_load_rhs_ptr ( + as_a <gimple_omp_atomic_load> (stmt)), + &pre, NULL, is_gimple_val, fb_rvalue); break; case GIMPLE_ASM: { diff --git a/gcc/omp-low.c b/gcc/omp-low.c index 23cf043..40cba5c 100644 --- a/gcc/omp-low.c +++ b/gcc/omp-low.c @@ -8186,7 +8186,9 @@ static void expand_omp_atomic (struct omp_region *region) { basic_block load_bb = region->entry, store_bb = region->exit; - gimple load = last_stmt (load_bb), store = last_stmt (store_bb); + gimple_omp_atomic_load load = + as_a <gimple_omp_atomic_load> (last_stmt (load_bb)); + gimple store = last_stmt (store_bb); tree loaded_val = gimple_omp_atomic_load_lhs (load); tree addr = gimple_omp_atomic_load_rhs (load); tree stored_val = gimple_omp_atomic_store_val (store); @@ -10524,7 +10526,8 @@ lower_omp_1 (gimple_stmt_iterator *gsi_p, omp_context *ctx) break; case GIMPLE_OMP_ATOMIC_LOAD: if ((ctx || task_shared_vars) - && walk_tree (gimple_omp_atomic_load_rhs_ptr (stmt), + && walk_tree (gimple_omp_atomic_load_rhs_ptr ( + as_a <gimple_omp_atomic_load> (stmt)), lower_omp_regimplify_p, ctx ? NULL : &wi, NULL)) gimple_regimplify_operands (stmt, gsi_p); break; -- 1.8.5.3
